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

  * VectorRibbon.java - Make a Mosaic

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2008 - Dick Balaska

  * 

  */

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

 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;

 import com.buckosoft.PicMan.domain.mosaic.MosaicVector;

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

  * "Best" is determined by subtracting the precalculated MosaicVectors 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/01/25

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

  */

 public class VectorRibbon extends MosaicEngine {

         private static final boolean DEBUG = true;

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

         private        int                curRow = 0;

         private        int                curCol = 0;

         private        int                maxRow;

         private        int                maxCol;

         private        int                p;

         private        List<Pic>                        picList;

         @SuppressWarnings("unused")

         private        List<MosaicVector>        vectorList;

         private        String        info = "N/A";

         private        long[]        used;

         /** Return our current build status

          * @return The status

          */

         public        String        getStatus() {

                 StringBuilder sb = new StringBuilder();

                 sb.append("curRow = ");

                 sb.append(curRow);

                 sb.append(" curCol = ");

                 sb.append(curCol);

                 sb.append(" p=");

                 sb.append(p);

                 return(sb.toString());

         }

         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);

                 vectorList = pmf.getDB().getMosaicVectors(picList);

                 if (DEBUG)

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

                 maxRow = this.masterPic.getHeight();

                 maxCol = this.masterPic.getWidth();

                 //int                rowHeight = maxRow / tileHeight;

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

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

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

                 if (DEBUG)

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

                 //restoreBuild(gd);

                 for (; curRow<maxRow; curRow += tileHeight, curCol=0) {

                         for (; curCol<maxCol; ) {

                                 int        x,y;

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

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

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

                                         rate[p] = used[p];

                                         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+curRow >= bi.getHeight())

                                                                 ppx = mpx;

                                                         else

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

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

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

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

                                                 }

                                         }

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

                                         // Give equal weight per pixel column

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

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

                                 }

                                 long best = Long.MAX_VALUE;

                                 int        besti = -1;

                                 int        besti2 = -1;

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

                                         if (rate[x] < best) {

                                                 besti2 = besti;

                                                 best = rate[x];

                                                 besti = x;

                                         }

                                 }

                                 if (DEBUG) {

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

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

                                 }

                                 used[besti]++;

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

                                 if (!mosaic.isBatch()) {

                                         MosaicTile        tile = new MosaicTile(this.mid, picList.get(besti).getPid(), curCol, curRow, mbi.getWidth(), mbi.getHeight());

                                         pmf.getDB().storeMosaicTile(tile);

                                 }

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

                                 curCol += mbi.getWidth();

                                 setLastMosaicUpdate();

                         }

                 }

                 return(false);

         }

         @SuppressWarnings("unused")

         private        void restoreBuild(Graphics2D gd) {

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

                 if (DEBUG)

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

                 for (; curRow<maxRow; curRow += tileHeight, curCol=0) {

                         for (; curCol<maxCol; ) {

                                 boolean found = false;

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

                                 while (iter.hasNext()) {

                                         MosaicTile mt = iter.next();

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

                                                 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, curRow);

                                                 curCol += mbi.getWidth();

                                                 setLastMosaicUpdate();

                                                 found = true;

                                                 break;

                                         }

                                 }

                                 if (!found)

                                         return;

                         }

                 }

         }

         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);

         }

 }