AI与电影分镜：机器学习故事板的链上版权

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title 分镜版权登记合约
 * @notice 为AI生成的电影分镜提供链上版权保护
 */
contract StoryboardCopyright {
    struct Storyboard {
        uint256 id;
        address creator;
        string ipfsHash;
        string filmTitle;
        string sceneDescription;
        uint256 shotNumber;
        string cameraAngle;
        string aiModel;
        string trainingDataHash;
        uint256 timestamp;
        bool isRegistered;
    }
    
    struct License {
        uint256 boardId;
        address licensee;
        string usageType;
        uint256 fee;
        uint256 timestamp;
        bool active;
    }
    
    mapping(uint256 => Storyboard) public storyboards;
    mapping(uint256 => License[]) public licenses;
    mapping(address => uint256[]) public creatorBoards;
    
    uint256 public nextBoardId;
    
    event StoryboardRegistered(uint256 indexed id, address creator, string ipfsHash);
    event LicenseGranted(uint256 indexed boardId, address licensee, string usageType);
    
    function registerStoryboard(
        string memory ipfsHash,
        string memory filmTitle,
        string memory sceneDescription,
        uint256 shotNumber,
        string memory cameraAngle,
        string memory aiModel,
        string memory trainingDataHash
    ) external returns (uint256) {
        uint256 id = nextBoardId++;
        storyboards[id] = Storyboard({
            id: id,
            creator: msg.sender,
            ipfsHash: ipfsHash,
            filmTitle: filmTitle,
            sceneDescription: sceneDescription,
            shotNumber: shotNumber,
            cameraAngle: cameraAngle,
            aiModel: aiModel,
            trainingDataHash: trainingDataHash,
            timestamp: block.timestamp,
            isRegistered: true
        });
        creatorBoards[msg.sender].push(id);
        emit StoryboardRegistered(id, msg.sender, ipfsHash);
        return id;
    }
    
    function grantLicense(
        uint256 boardId,
        address licensee,
        string memory usageType,
        uint256 fee
    ) external payable {
        require(storyboards[boardId].creator == msg.sender, "Not the creator");
        require(msg.value >= fee, "Insufficient fee");
        
        licenses[boardId].push(License({
            boardId: boardId,
            licensee: licensee,
            usageType: usageType,
            fee: fee,
            timestamp: block.timestamp,
            active: true
        }));
        
        payable(msg.sender).transfer(msg.value);
        emit LicenseGranted(boardId, licensee, usageType);
    }
    
    function getCreatorBoards(address creator) 
        external view returns (uint256[] memory) {
        return creatorBoards[creator];
    }
}

import numpy as np
from PIL import Image
import torch
from diffusers import StableDiffusionPipeline
from typing import List, Dict
import json

class AIStoryboardGenerator:
    """AI分镜生成系统"""
    
    def __init__(self, model_id: str = "runwayml/stable-diffusion-v1-5"):
        self.pipe = StableDiffusionPipeline.from_pretrained(
            model_id, 
            torch_dtype=torch.float16
        )
        self.pipe = self.pipe.to("cuda")
        
    def generate_shot(
        self, 
        prompt: str,
        camera_angle: str,
        mood: str,
        num_steps: int = 50
    ) -> Image.Image:
        """生成单个镜头分镜"""
        enhanced_prompt = f"{camera_angle} shot of {prompt}, {mood} lighting, cinematic, storyboard style"
        result = self.pipe(
            enhanced_prompt,
            num_inference_steps=num_steps,
            guidance_scale=7.5
        )
        return result.images[0]
    
    def generate_sequence(
        self, 
        scene_script: List[Dict],
        output_dir: str
    ) -> List[str]:
        """生成完整分镜序列"""
        image_paths = []
        for i, shot in enumerate(scene_script):
            image = self.generate_shot(
                shot['description'],
                shot['camera_angle'],
                shot['mood']
            )
            path = f"{output_dir}/shot_{i:03d}.png"
            image.save(path)
            image_paths.append(path)
        return image_paths
    
    def generate_ipfs_hash(self, image: Image.Image) -> str:
        """生成分镜的IPFS哈希"""
        import hashlib
        return hashlib.sha256(image.tobytes()).hexdigest()

generator = AIStoryboardGenerator()
scene = [
    {"description": "a detective walking through rain", "camera_angle": "low angle", "mood": "noir"},
    {"description": "a mysterious figure in shadows", "camera_angle": "close-up", "mood": "suspenseful"}
]
paths = generator.generate_sequence(scene, "./storyboards")

const ethers = require('ethers');

class StoryboardMarketplace {
  constructor(contractAddress, providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.contract = new ethers.Contract(contractAddress, StoryboardCopyrightABI, this.provider);
  }

  async listStoryboard(boardId, price, signer) {
    const contract = this.contract.connect(signer);
    const tx = await contract.setListingPrice(boardId, price);
    await tx.wait();
    return tx;
  }

  async purchaseStoryboard(boardId, signer) {
    const listing = await this.contract.listings(boardId);
    const contract = this.contract.connect(signer);
    const tx = await contract.purchaseBoard(boardId, { value: listing.price });
    await tx.wait();
    return tx;
  }

  async searchBoards(keyword) {
    const total = await this.contract.nextBoardId();
    const results = [];
    for (let i = 1; i < total.toNumber(); i++) {
      const board = await this.contract.storyboards(i);
      if (board.isRegistered) {
        results.push(board);
      }
    }
    return results;
  }
}

const marketplace = new StoryboardMarketplace(
  '0xContractAddress',
  'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY'
);