perchance-ai-prompt-library/src/generators/PhotographyGenerator.js

🎨 Complete AI prompt library and generator with advanced CLI, batch processing, analytics, and multi-format export capabilities

const fs = require('fs');
const path = require('path');
const { randomChoice } = require('../utils/helpers');

class PhotographyGenerator {
  constructor() {
    this.standards = this.loadStandards();
  }

  loadStandards() {
    try {
      const data = fs.readFileSync(
        path.join(__dirname, '../data/photographyStandards.json'),
        'utf8'
      );
      return JSON.parse(data);
    } catch (error) {
      console.error('Error loading photography standards:', error);
      return {
        resolutions: {},
        camera_settings: {},
        lighting_conditions: [],
        professional_terms: {},
        equipment: {},
        composition_rules: []
      };
    }
  }

  // Resolution helpers
  getResolution(type = 'standard', format = 'landscape') {
    const resolutions = this.standards.resolutions[type]?.[format];
    return resolutions ? randomChoice(resolutions) : '';
  }

  // Camera settings
  getCameraSettings() {
    const settings = this.standards.camera_settings;
    return {
      aperture: randomChoice(settings.aperture),
      shutterSpeed: randomChoice(settings.shutter_speed),
      iso: randomChoice(settings.iso),
      focalLength: randomChoice(settings.focal_length)
    };
  }

  // Professional terms
  getProfessionalTerms(count = 3) {
    const terms = [];
    const categories = Object.values(this.standards.professional_terms).flat();
    
    while (terms.length < count && categories.length > 0) {
      const term = randomChoice(categories);
      if (!terms.includes(term)) {
        terms.push(term);
      }
    }
    
    return terms;
  }

  // Generate a professional photography prompt
  generatePrompt(options = {}) {
    const {
      subject = 'a professional photograph',
      style = 'standard',
      format = 'landscape',
      includeSettings = true,
      includeEquipment = false,
      termCount = 3,
      customTerms = []
    } = options;

    const resolution = this.getResolution(style, format);
    const cameraSettings = includeSettings ? this.getCameraSettings() : null;
    const professionalTerms = [...this.getProfessionalTerms(termCount), ...customTerms];
    const lighting = randomChoice(this.standards.lighting_conditions);
    const composition = randomChoice(this.standards.composition_rules);

    // Build the prompt parts
    const promptParts = [];
    
    // Add resolution if available
    if (resolution) {
      promptParts.push(`${resolution}`);
    }
    
    // Add subject
    promptParts.push(subject);
    
    // Add camera settings if enabled
    if (cameraSettings) {
      promptParts.push(
        `shot on ${cameraSettings.focalLength} at ${cameraSettings.aperture}, ${cameraSettings.shutterSpeed}, ISO ${cameraSettings.iso}`
      );
    }
    
    // Add lighting
    promptParts.push(`in ${lighting}`);
    
    // Add composition
    promptParts.push(`with ${composition}`);
    
    // Add professional terms
    if (professionalTerms.length > 0) {
      promptParts.push(professionalTerms.join(', '));
    }
    
    // Add equipment if enabled
    if (includeEquipment) {
      const brand = randomChoice(this.standards.equipment.camera_brands);
      const lens = randomChoice(this.standards.equipment.lens_types);
      promptParts.push(`taken with ${brand} camera and ${lens}`);
    }

    return promptParts.join(', ');
  }

  // Generate multiple prompts with variations
  generateBatch(options = {}, count = 5) {
    const prompts = [];
    for (let i = 0; i < count; i++) {
      prompts.push(this.generatePrompt(options));
    }
    return prompts;
  }
}

module.exports = PhotographyGenerator;