API tools faq
paste
Guest User

C++ project

a guest
May 6th, 2026
61
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 11.30 KB | Source Code | 0 0
raw download clone embed print report
  1. #include "ImageToSpriteConverter.hpp"
  2. #include <iostream>
  3. #include <iomanip>
  4. #include <algorithm>
  5. #include <cmath>
  6.  
  7. namespace HokutoConverter {
  8.  
  9. ImageToSpriteConverter::ImageToSpriteConverter()
  10.     : currentX(0), currentY(0), spritesPerRow(10), rng(std::random_device{}()) {
  11.     masterSpriteSheet = cv::Mat(cv::Size(32 * spritesPerRow, 32 * 100),
  12.                                 CV_8UC3, cv::Scalar(0, 0, 0));
  13.     initializeCharacterPalettes();
  14.     initializeColorMaps();
  15. }
  16.  
  17. ImageToSpriteConverter::~ImageToSpriteConverter() {}
  18.  
  19. void ImageToSpriteConverter::initializeCharacterPalettes() {
  20.     // KENSHIRO - Blue outfit, black hair, tan skin
  21.     characterPalettes[HokutoCharacter::KENSHIRO] = {
  22.         cv::Scalar(50, 50, 80),     // primary - dark blue
  23.         cv::Scalar(30, 30, 50),     // secondary
  24.         cv::Scalar(255, 224, 189),  // skin
  25.         cv::Scalar(0, 0, 0),        // hair - black
  26.         cv::Scalar(0, 0, 0),        // eyes
  27.         cv::Scalar(255, 100, 0)     // aura - orange
  28.     };
  29.    
  30.     // REI - Purple outfit, blonde hair
  31.     characterPalettes[HokutoCharacter::REI] = {
  32.         cv::Scalar(150, 100, 150),  // primary - purple
  33.         cv::Scalar(130, 80, 130),   // secondary
  34.         cv::Scalar(255, 230, 205),  // skin - light
  35.         cv::Scalar(255, 200, 150),  // hair - blonde
  36.         cv::Scalar(100, 100, 200),  // eyes - blue
  37.         cv::Scalar(100, 200, 255)   // aura - water blue
  38.     };
  39.    
  40.     // RAOH - Brown armor, tan skin
  41.     characterPalettes[HokutoCharacter::RAOH] = {
  42.         cv::Scalar(80, 50, 30),     // primary - brown
  43.         cv::Scalar(60, 40, 20),     // secondary
  44.         cv::Scalar(245, 215, 180),  // skin - tan
  45.         cv::Scalar(30, 30, 30),     // hair - dark brown
  46.         cv::Scalar(150, 50, 50),    // eyes - red
  47.         cv::Scalar(150, 0, 150)     // aura - purple
  48.     };
  49.    
  50.     // TOKI - Blue outfit, light brown hair
  51.     characterPalettes[HokutoCharacter::TOKI] = {
  52.         cv::Scalar(100, 100, 120),  // primary - light blue
  53.         cv::Scalar(80, 80, 100),    // secondary
  54.         cv::Scalar(255, 235, 210),  // skin - pale
  55.         cv::Scalar(200, 180, 150),  // hair - light brown
  56.         cv::Scalar(100, 100, 100),  // eyes - gray
  57.         cv::Scalar(100, 200, 200)   // aura - cyan
  58.     };
  59.    
  60.     // SHIN - White outfit, black hair
  61.     characterPalettes[HokutoCharacter::SHIN] = {
  62.         cv::Scalar(200, 200, 200),  // primary - white
  63.         cv::Scalar(180, 180, 180),  // secondary
  64.         cv::Scalar(255, 220, 195),  // skin - light
  65.         cv::Scalar(0, 0, 0),        // hair - black
  66.         cv::Scalar(50, 50, 150),    // eyes - blue
  67.         cv::Scalar(200, 200, 255)   // aura - white
  68.     };
  69.    
  70.     // SOUTHER - Red armor, blonde hair
  71.     characterPalettes[HokutoCharacter::SOUTHER] = {
  72.         cv::Scalar(200, 50, 50),    // primary - red
  73.         cv::Scalar(180, 30, 30),    // secondary
  74.         cv::Scalar(255, 225, 200),  // skin
  75.         cv::Scalar(255, 255, 0),    // hair - gold
  76.         cv::Scalar(100, 100, 255),  // eyes - blue
  77.         cv::Scalar(255, 100, 100)   // aura - red
  78.     };
  79.    
  80.     // KAIOH - Purple armor, golden hair
  81.     characterPalettes[HokutoCharacter::KAIOH] = {
  82.         cv::Scalar(100, 50, 150),   // primary - purple
  83.         cv::Scalar(80, 30, 130),    // secondary
  84.         cv::Scalar(235, 205, 170),  // skin - dark
  85.         cv::Scalar(255, 200, 50),   // hair - gold
  86.         cv::Scalar(255, 50, 50),    // eyes - red
  87.         cv::Scalar(150, 0, 200)     // aura - dark purple
  88.     };
  89.    
  90.     // HYOH - Red armor, golden hair
  91.     characterPalettes[HokutoCharacter::HYOH] = {
  92.         cv::Scalar(150, 50, 50),    // primary - dark red
  93.         cv::Scalar(130, 30, 30),    // secondary
  94.         cv::Scalar(255, 225, 190),  // skin
  95.         cv::Scalar(255, 200, 100),  // hair - golden
  96.         cv::Scalar(200, 100, 100),  // eyes - red
  97.         cv::Scalar(200, 100, 0)     // aura - orange
  98.     };
  99.    
  100.     // FALCO - Golden armor
  101.     characterPalettes[HokutoCharacter::FALCO] = {
  102.         cv::Scalar(255, 215, 0),    // primary - gold
  103.         cv::Scalar(235, 195, 0),    // secondary
  104.         cv::Scalar(255, 225, 195),  // skin
  105.         cv::Scalar(255, 215, 0),    // hair - gold
  106.         cv::Scalar(100, 100, 200),  // eyes
  107.         cv::Scalar(255, 215, 0)     // aura - gold
  108.     };
  109.    
  110.     // JUZA - Green outfit, golden hair
  111.     characterPalettes[HokutoCharacter::JUZA] = {
  112.         cv::Scalar(100, 150, 50),   // primary - green
  113.         cv::Scalar(80, 130, 30),    // secondary
  114.         cv::Scalar(255, 225, 200),  // skin
  115.         cv::Scalar(255, 200, 100),  // hair - golden
  116.         cv::Scalar(100, 200, 100),  // eyes
  117.         cv::Scalar(100, 255, 100)   // aura - green
  118.     };
  119.    
  120.     // YUDA - Pink outfit
  121.     characterPalettes[HokutoCharacter::YUDA] = {
  122.         cv::Scalar(255, 50, 100),   // primary - pink
  123.         cv::Scalar(235, 30, 80),    // secondary
  124.         cv::Scalar(255, 230, 210),  // skin - pale
  125.         cv::Scalar(255, 100, 150),  // hair - pink
  126.         cv::Scalar(200, 100, 200),  // eyes
  127.         cv::Scalar(255, 100, 150)   // aura - pink
  128.     };
  129.    
  130.     // SHACHI - Blue outfit, black hair
  131.     characterPalettes[HokutoCharacter::SHACHI] = {
  132.         cv::Scalar(50, 100, 150),   // primary - blue
  133.         cv::Scalar(30, 80, 130),    // secondary
  134.         cv::Scalar(245, 215, 180),  // skin - tan
  135.         cv::Scalar(0, 0, 0),        // hair - black
  136.         cv::Scalar(100, 150, 200),  // eyes
  137.         cv::Scalar(100, 200, 255)   // aura - blue
  138.     };
  139.    
  140.     // HAN - Gray armor
  141.     characterPalettes[HokutoCharacter::HAN] = {
  142.         cv::Scalar(100, 100, 100),  // primary - gray
  143.         cv::Scalar(80, 80, 80),     // secondary
  144.         cv::Scalar(245, 215, 180),  // skin
  145.         cv::Scalar(150, 100, 50),   // hair - brown
  146.         cv::Scalar(150, 100, 50),   // eyes
  147.         cv::Scalar(200, 150, 100)   // aura - brown
  148.     };
  149.    
  150.     // JUKEI - Brown robe, white hair
  151.     characterPalettes[HokutoCharacter::JUKEI] = {
  152.         cv::Scalar(100, 80, 60),    // primary - brown
  153.         cv::Scalar(80, 60, 40),     // secondary
  154.         cv::Scalar(235, 205, 170),  // skin - wrinkled
  155.         cv::Scalar(200, 200, 200),  // hair - white
  156.         cv::Scalar(100, 100, 100),  // eyes - gray
  157.         cv::Scalar(255, 215, 0)     // aura - gold
  158.     };
  159.    
  160.     // SHEW - Yellow/tan outfit, white hair
  161.     characterPalettes[HokutoCharacter::SHEW] = {
  162.         cv::Scalar(200, 200, 100),  // primary - yellow
  163.         cv::Scalar(180, 180, 80),   // secondary
  164.         cv::Scalar(245, 215, 180),  // skin - tan
  165.         cv::Scalar(255, 255, 255),  // hair - white
  166.         cv::Scalar(100, 100, 100),  // eyes
  167.         cv::Scalar(255, 255, 200)   // aura - light yellow
  168.     };
  169. }
  170.  
  171.  
  172.  
  173. ConvertedResult ImageToSpriteConverter::convertImageToSprite(const std::string& imagePath,
  174.                                                               HokutoCharacter character,
  175.                                                               const ConversionConfig& customConfig) {
  176.     auto start = std::chrono::steady_clock::now();
  177.    
  178.     ConvertedResult result;
  179.     result.originalFile = imagePath;
  180.     result.character = character;
  181.    
  182.     // Load image
  183.     cv::Mat original = cv::imread(imagePath);
  184.     if(original.empty()) {
  185.         std::cerr << "Failed to load image: " << imagePath << std::endl;
  186.         stats.failed++;
  187.         return result;
  188.     }
  189.    
  190.     // Update config
  191.     config = customConfig;
  192.    
  193.     // Detect image source type
  194.     ImageSourceType sourceType = detectImageSource(original);
  195.     stats.sourceTypeCount[sourceType]++;
  196.    
  197.     // Adjust config based on source type
  198.     if(config.quality == QualityPreset::NORMAL) {
  199.         switch(sourceType) {
  200.             case ImageSourceType::ANIME_SCREENSHOT:
  201.             case ImageSourceType::ANIME_ARTWORK:
  202.                 config.colorDepth = 32;
  203.                 config.pixelBlockSize = 1.5f;
  204.                 break;
  205.             case ImageSourceType::THREE_D_RENDER:
  206.                 config.colorDepth = 64;
  207.                 config.pixelBlockSize = 3.0f;
  208.                 config.edgeEnhancement = true;
  209.                 break;
  210.             case ImageSourceType::HD_PHOTO:
  211.                 config.colorDepth = 128;
  212.                 config.pixelBlockSize = 4.0f;
  213.                 config.dithering = true;
  214.                 break;
  215.             default:
  216.                 break;
  217.         }
  218.     }
  219.    
  220.     // Convert to pixel art based on character
  221.     cv::Mat pixelArt;
  222.     switch(character) {
  223.         case HokutoCharacter::KENSHIRO:
  224.             result = convertToKenshiro(original, config);
  225.             break;
  226.         case HokutoCharacter::REI:
  227.             result = convertToRei(original, config);
  228.             break;
  229.         case HokutoCharacter::RAOH:
  230.             result = convertToRaoh(original, config);
  231.             break;
  232.         case HokutoCharacter::TOKI:
  233.             result = convertToToki(original, config);
  234.             break;
  235.         case HokutoCharacter::SHIN:
  236.             result = convertToShin(original, config);
  237.             break;
  238.         case HokutoCharacter::SOUTHER:
  239.             result = convertToSouther(original, config);
  240.             break;
  241.         case HokutoCharacter::KAIOH:
  242.             result = convertToKaioh(original, config);
  243.             break;
  244.         case HokutoCharacter::HYOH:
  245.             result = convertToHyoh(original, config);
  246.             break;
  247.         case HokutoCharacter::FALCO:
  248.             result = convertToFalco(original, config);
  249.             break;
  250.         case HokutoCharacter::JUZA:
  251.             result = convertToJuza(original, config);
  252.             break;
  253.         case HokutoCharacter::YUDA:
  254.             result = convertToYuda(original, config);
  255.             break;
  256.         case HokutoCharacter::SHACHI:
  257.             result = convertToShachi(original, config);
  258.             break;
  259.         case HokutoCharacter::HAN:
  260.             result = convertToHan(original, config);
  261.             break;
  262.         case HokutoCharacter::JUKEI:
  263.             result = convertToJukei(original, config);
  264.             break;
  265.         case HokutoCharacter::SHEW:
  266.             result = convertToShew(original, config);
  267.             break;
  268.         default:
  269.             result = convertToKenshiro(original, config);
  270.     }
  271.    
  272.     // Apply character palette
  273.     cv::Mat paletted = applyCharacterPalette(result.sprite, character);
  274.    
  275.     // Resize to target size
  276.     cv::Mat finalSprite;
  277.     resizeKeepAspect(paletted, finalSprite, config.targetSize);
  278.    
  279.     // Add to sprite sheet
  280.     std::string spriteName = getCharacterName(character) + "_" + fs::path(imagePath).stem().string();
  281.     addToSpriteSheet(finalSprite, spriteName, character);
  282.    
  283.     // Update result
  284.     result.sprite = finalSprite;
  285.     result.spriteName = spriteName;
  286.     result.finalSize = config.targetSize;
  287.    
  288.     auto end = std::chrono::steady_clock::now();
  289.     result.conversionTime = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
  290.    
  291.     // Update statistics
  292.     stats.totalProcessed++;
  293.     stats.successful++;
  294.     stats.characterCount[character]++;
  295.     stats.totalTime += result.conversionTime;
  296.    
  297.     std::cout << "✓ " << getCharacterName(character) << " ← "
  298.               << fs::path(imagePath).filename().string()
  299.               << " (" << result.conversionTime << "ms)" << std::endl;
  300.    
  301.     return result;
  302. }
  303.  
  304.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!