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

  * MosaicManDevelopment.java - Development methods to work out mosaic building algorithms

  * 

  * PicMan - The BuckoSoft Picture Manager in Java

  * Copyright(c) 2007 - Dick Balaska

  * 

  */

 package com.buckosoft.PicMan.business.mosaic;

 import java.awt.Color;

 import java.awt.Graphics2D;

 import java.awt.image.BufferedImage;

 import java.util.Date;

 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.PicManFacade;

 import com.buckosoft.PicMan.domain.JobLogEntry;

 import com.buckosoft.PicMan.domain.Pic;

 import com.buckosoft.PicMan.domain.Thumbnail;

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

 /** Mosaic test/development methods to work out mosaic building algorithms. <br>

  * These are obsolete and could probably be deleted, but who knows... <br>

  * These were hacked out of MosaicMan to clean him up so that he just does building managing.

  * @author Dick Balaska

  * @since 2008/07/01

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

  */

 public class MosaicManDevelopment {

         private static final boolean DEBUG = true;

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

         private        PicManFacade        pmf;

         private        int picProcessing = 0;

         /** Set the reference to the PicMan API.

          * @param pmf The PicManFacade

          */

         public        void setPicMan(PicManFacade pmf) {

                 this.pmf = pmf;

         }

         /** Which ordinal picture are we working on?

          * This is just a status indicator

          * @return the picProcessing

          */

         public int getPicProcessing() {

                 return picProcessing;

         }

         /** A Test/Development method that returns a thumbnail that is a mosaic of the pic.

          * @param pic The Pic to make a mosaic thumb of

          * @param height  The height of the resulting Thumbnail

          * @param depth The number of divisions in the resulting Thumbnail. '3' will make a 3x3 mosaic.

          * @return The mosaic'd thumbnail

          */

         public Thumbnail        getMosaicThumbNail(Pic pic, int height, int depth) {

                 Thumbnail tn = pmf.getThumbNail(pic, height);

                 BufferedImage bi = tn.getImage();

                 BufferedImage nbi = new BufferedImage(bi.getWidth(), bi.getHeight(), BufferedImage.TYPE_INT_BGR);

                 Graphics2D g = nbi.createGraphics();

                 int width = bi.getWidth();

                 for (int xm=0; xm<depth; xm++) {

                         for (int ym=0; ym<depth; ym++) {

                                 long sumr = 0, sumg=0, sumb=0;

                                 int        count = 0;

                                 for (int x=xm*width/depth; x<(xm+1)*width/depth; x++) {

                                         //if (DEBUG)

                                         //        logger.info("x=" + x);

                                         for (int y=ym*height/depth; y<(ym+1)*height/depth; y++) {

                                         //        if (DEBUG)

                                         //                logger.info("  y=" + y);

                                                 int rgb = bi.getRGB(x, y);

                                                 sumb += rgb & 0xff;

                                                 sumg += rgb >> 8 & 0xff;

                                                 sumr += rgb >> 16 & 0xff;

                                                 count++;

                                         }

                                 }

                                 int _r = (int)((double)sumr/(double)count);

                                 int _g = (int)((double)sumg/(double)count);

                                 int _b = (int)((double)sumb/(double)count);

                                 g.setColor(new Color(_r, _g, _b));

                                 int _x = xm*width/depth;

                                 int _y = ym*height/depth;

                                 int _w = (xm+1)*width/depth-_x;

                                 int _h = (ym+1)*height/depth-_y;

 //                                if (DEBUG)

 //                                        logger.info(" d = " + depth + " x/y = " + _x + "/" + _y + "  w/h = " + _w + "/" + _h);

                                 g.fillRect(_x, _y, _w, _h);

                         }

                 }

                 tn.setImage(nbi);

                 return(tn);

         }

         public MosaicVector        getMosaicVector(Pic pic) {

                 final int height = 300;                // let's deal with the thumbs as 300 high for now

                 MosaicVector mv = new MosaicVector();

                 mv.pid = pic.getPid();

                 Thumbnail tn;

                 BufferedImage bi;

                 try {

                         tn = pmf.getThumbNail(pic, height);

                         bi = tn.getImage();

                 } catch (Exception e) {

                         return(null);

                 }

                 //int width = bi.getWidth();

                 int rgb = calculateVector(bi, 1, 0, 0);

                 mv.rgb = rgb;

                 int x;

                 int        y;

                 for (x=0; x<2; x++) {

                         for (y=0; y<2; y++) {

                                 mv.rgb2[x][y] = calculateVector(bi, 2, x, y);

                         }

                 }

                 for (x=0; x<3; x++) {

                         for (y=0; y<3; y++) {

                                 mv.rgb3[x][y] = calculateVector(bi, 3, x, y);

                         }

                 }

                 return(mv);

         }

         private        int        calculateVector(BufferedImage bi, int depth, int xm, int ym) {

                 long sumr = 0, sumg=0, sumb=0;

                 int        count = 0;

                 int width = bi.getWidth();

                 int height = bi.getHeight();

                 for (int x=xm*width/depth; x<(xm+1)*width/depth; x++) {

                         //if (DEBUG)

                         //        logger.info("x=" + x);

                         for (int y=ym*height/depth; y<(ym+1)*height/depth; y++) {

                         //        if (DEBUG)

                         //                logger.info("  y=" + y);

                                 int rgb = bi.getRGB(x, y);

                                 sumb += rgb & 0xff;

                                 sumg += rgb >> 8 & 0xff;

                                 sumr += rgb >> 16 & 0xff;

                                 count++;

                         }

                 }

                 int _r = (int)((double)sumr/(double)count);

                 int _g = (int)((double)sumg/(double)count);

                 int _b = (int)((double)sumb/(double)count);

                 return(_r<<16 | _g<<8 | _b);

         }

         /** Read every Pic and calculate the mosaic vectors for it

          */

         public void runVectors() {

                 if (DEBUG)

                         logger.info("runVectors()");

                 picProcessing = 0;

                 List<Pic> pics = pmf.getDB().getPics();

                 JobLogEntry jle = new JobLogEntry();

                 jle.setType(JobLogEntry.MOSAICV);

                 pmf.addJobToLog(jle);

                 Iterator<Pic> iter = pics.iterator();

                 while (iter.hasNext()) {

                         Pic pic = iter.next();

                         MosaicVector mv = getMosaicVector(pic);

                         if (mv != null)

                                 pmf.getDB().updateMosaicVectors(mv);

                         picProcessing++;

                 }

                 jle.setEndTime(new Date());

         }

 }