/******************************************************************************

  * HSVRibbon.java - Make a Mosaic with the HSV color model

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2008 - Dick Balaska

  * 

  */

 package com.buckosoft.PicMan.business.mosaic.engine;

 import java.awt.Color;

 import java.awt.Graphics2D;

 import java.awt.image.BufferedImage;

 import java.util.Iterator;

 import java.util.List;

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

 import com.buckosoft.PicMan.business.mosaic.MosaicEngine;

 import com.buckosoft.PicMan.domain.MosaicTile;

 import com.buckosoft.PicMan.domain.Pic;

 /** Rework FirstMosaic using an HSV color model instead of an RGB color model. <br>

  * This engine walks through each row of a Pic and places the best tile there. <br>

  * "Best" is determined by subtracting the tile from the Pic and summing the different in each pixel.

  * This is performed from each tile in the set, and the one with the least difference is chosen.  

  * @author Dick Balaska

  * @since 2008/05/27

  * @see <a href="http://cvs.buckosoft.com/Projects/java/PicMan/PicMan/src/main/java/com/buckosoft/PicMan/business/mosaic/engine/HSVRibbon.java">HSVRibbon.java</a>

  */

 public class HSVRibbon extends MosaicEngine {

         private static final boolean DEBUG = true;

         private final Log logger = LogFactory.getLog(getClass());

         private        int                mosaicId = 2;

         private        int                curRow = 0;

         private        int[]        curCols;

         private        int                curCol;

         private        int                maxRow;

         private        int                maxCol;

         private        int                p;

         private        List<Pic>        picList;

         private        String        info = "N/A";

         private        int[]        used;

         private        int                tileRows;

         private        String        buildStep = "Idle";

         private        int                pass = -1;

         /** Return our current build status

          * @return The status

          */

         public        String        getStatus() {

                 StringBuilder sb = new StringBuilder();

                 sb.append(buildStep);

                 sb.append(": pass=");

                 sb.append(pass);

                 if (!buildStep.equals("Calc")) {

                         sb.append(" curRow = ");

                         sb.append(curRow);

                         sb.append(" curCol = ");

                         sb.append(curCol);

                 }

                 sb.append(" p=");

                 sb.append(p);

                 return(sb.toString());

         }

         /** Return a semi-static info string

          * @return "tileRows= y maxCol= x pics=n

          */

         public String getInfo() {

                 return(info);

         }

         protected boolean _build() {

                 Graphics2D        gd = bi.createGraphics();

                 // 75, pull from this size set even though the size calc should be able to deal with, say, a 50 and figure it out.

                 picList = pmf.getDB().getPics(this.mosaicSet, 75);

                 if (DEBUG)

                         logger.info("Working from " + picList.size() + " pics");

                 maxRow = this.masterPic.getHeight();

                 maxCol = this.masterPic.getWidth();

                 tileRows = maxRow / tileHeight;

                 if (tileRows * tileHeight < maxRow)

                         tileRows++;

                 curCols = new int[tileRows];

                 float[][]        rate = new float[tileRows][picList.size()];                // rate each pic for this location

                                         used = new int[picList.size()];                // number of times each pic is used

                 info = "tileRows=" + tileRows + " maxCol=" + maxCol + " pics=" + picList.size();

                 if (DEBUG)

                         logger.info("tileRows=" + tileRows + " rowHeight=" + tileHeight);

                 restoreBuild(gd);

                 boolean workDone = true;

                 float[] mpxHsb = new float[3];

                 float[] ppxHsb = new float[3];

                 while (workDone) {

                         pass++;

                         workDone = false;

                         BufferedImage mbi;

                         int        x,y;

                         buildStep = "Calc";

                         for (p=0; p<picList.size(); p++) {

                                 mbi = pmf.getMosaicThumbNail(picList.get(p), tileHeight).getImage();

                                 for (curRow=0; curRow<tileRows; curRow++) {

                                         curCol = curCols[curRow];

                                         int        cr = curRow * tileHeight;

 //                                        if (DEBUG) {

 //                                                if (curRow == 28 && pass == 4)

 //                                                        logger.info("pass 4 row 28");

 //                                        }

                                         if (curCol < maxCol) {

                                                 workDone = true;

                                                 //BufferedImage mbi = pmf.getThumbNail(null, tileHeight).getImage();

                                                 rate[curRow][p] = used[p];

                                                 rate[curRow][p] = 0;

                                                 for (x=0; x<mbi.getWidth(); x++) {

                                                         for (y=0; y<mbi.getHeight(); y++) {

                                                                 int mpx = mbi.getRGB(x, y);

                                                                 int        ppx;

                                                                 if (x+curCol >= bi.getWidth() || y+cr >= bi.getHeight())

                                                                         ppx = mpx;

                                                                 else

                                                                         ppx = bi.getRGB(x+curCol, y+cr);

                                                                 Color.RGBtoHSB((mpx>>16) & 0xFF, (mpx>>8) & 0xFF, mpx&0xFF, mpxHsb);

                                                                 Color.RGBtoHSB((ppx>>16) & 0xFF, (ppx>>8) & 0xFF, ppx&0xFF, ppxHsb);

                                                                 if (ppxHsb[0] > mpxHsb[0]) ppxHsb[0] += 1.0;

                                                                 rate[curRow][p] += Math.abs(mpxHsb[0] - ppxHsb[0]);

                                                                 rate[curRow][p] += Math.abs(mpxHsb[0] - ppxHsb[0]);

                                                                 rate[curRow][p] += Math.abs(mpxHsb[0] - ppxHsb[0]);

                                                                 //rate[curRow][p] += Math.abs(((mpx)&0xFF)     - ((ppx)&0xFF))     * 1;

                                                                 //rate[curRow][p] += Math.abs(((mpx>>8)&0xFF)  - ((ppx>>8)&0xFF))  * 1;

                                                                 //rate[curRow][p] += Math.abs(((mpx>>16)&0xFF) - ((ppx>>16)&0xFF)) * 1;

                                                         }

                                                 }

                                                 // Portrait always wins over landscape because there is less pixels to go wrong.

                                                 // Give equal weight per pixel column

                                                 rate[curRow][p] /= mbi.getWidth();

                                                 //logger.info("rate[" + p + "]=" + rate[p] + " ("+ picList.get(p).getName() + ")");

                                         }

                                 }

                         }

                         buildStep = "Draw";

                         for (curRow=0; curRow<tileRows; curRow++) {

                                 curCol = curCols[curRow];

                                 int cr = curRow * tileHeight;

                                 if (curCol >= maxCol)

                                         continue;

                                 float        best = Float.MAX_VALUE;

                                 int                besti = -1;

                                 int                besti2 = -1;

                                 for (x=0; x<rate.length; x++) {

                                         if (rate[curRow][x] < best) {

                                                 besti2 = besti;

                                                 best = rate[curRow][x];

                                                 besti = x;

                                         }

                                 }

                                 p = besti;

                                 if (DEBUG) {

                                         if (besti == -1)

                                                 logger.info("row=" + curRow + " besti == -1");

                                         else

                                                 logger.info("besti = " + besti + " (" + picList.get(besti).getName() + ") = " + rate[curRow][besti]);

                                         if (besti2 == -1)

                                                 logger.info("row=" + curRow + " besti2 == -1");

                                         else

                                                 logger.info("besti2 = " + besti2 + " (" + picList.get(besti2).getName() + ") = " + rate[curRow][besti2]);

                                 }

                                 used[besti]++;

                                 mbi = pmf.getThumbNail(picList.get(besti), tileHeight).getImage();

                                 MosaicTile        tile = new MosaicTile(mosaicId, picList.get(besti).getPid(), curCol, cr, mbi.getWidth(), mbi.getHeight());

                                 pmf.getDB().storeMosaicTile(tile);

                                 gd.drawImage(mbi, null, curCol, cr);

                                 curCols[curRow] += mbi.getWidth();

                                 setLastMosaicUpdate();

                         }

                 }

                 buildStep = "Done";

                 return(false);

         }

         private        void restoreBuild(Graphics2D gd) {

                 List<MosaicTile> lmt = pmf.getDB().getMosaicTiles(mosaicId);

                 if (DEBUG)

                         logger.info("Restoring " + lmt.size() + " tiles");

                 boolean workDone = true;

                 buildStep = "Restore";

                 while (workDone) {

                         workDone = false;

                         pass++;

                         updateRestoreStatus();

                         for (curRow=0; curRow<tileRows; curRow++) {

                                 curCol = curCols[curRow];

                                 int        cr = curRow * tileHeight;

                                 Iterator<MosaicTile> iter = lmt.iterator();

                                 while (iter.hasNext()) {

                                         MosaicTile mt = iter.next();

                                         if (mt.getX() == curCol && mt.getY() == cr) {

                                                 int besti = getPicListIndex(mt.getPid());

                                                 if (DEBUG)

                                                         logger.info("restore: besti = " + besti + " (" + picList.get(besti).getName() + ")");

                                                 used[besti]++;

                                                 BufferedImage mbi = pmf.getThumbNail(picList.get(besti), tileHeight).getImage();

                                                 gd.drawImage(mbi, null, curCol, cr);

                                                 curCols[curRow] += mbi.getWidth();

                                                 setLastMosaicUpdate();

                                                 workDone = true;

                                                 break;

                                         }

                                 }

                         }

                 }

         }

         private        void updateRestoreStatus() {

                 buildStep = "Restore";

         }

         private        int        getPicListIndex(int pid) {

                 for (int i=0; i<picList.size(); i++) {

                         Pic p = picList.get(i);

                         if (p.getPid() == pid)

                                 return(i);

                 }

                 return(-1);

         }

 }