Forum |  HardWare.fr | News | Articles | PC | S'identifier | S'inscrire | Shop Recherche
1168 connectés 

  FORUM HardWare.fr
  Programmation
  Java

  aidez moi svp dans la compréhension de ce code

 
 


 Mot :   Pseudo :  
 
Bas de page
Auteur Sujet :

aidez moi svp dans la compréhension de ce code

n°2076024
jaki1910
Posté le 15-05-2011 à 16:16:46  profilanswer
 

Bonjour,
est ce que svp je peux savoir d’après ce code comment il detecte si les pieces sont bien mises et que le puzzle est résolu.
je pense que apres le clique sur la piece il recupere son identifiant, mais je ne comprends pas comment sa voisine est detecté avant de les coller?
 
Merci beaucoup pour votre aide.
 :??:  

Code :
  1. /**
  2. *Each piece knows the portion of the image it contains, how its edges are to *be drawn, and what its
  3. * neighboring pieces are.
  4. *
  5. * <p> When two or more Pieces are put together, the result is another
  6. * Piece object, a MultiPiece.
  7. *
  8. * @see MultiPiece
  9. */
  10. public class Piece implements Serializable
  11. {
  13. // Class constants ------------------------------------------------------
  14. /** Unique id for the next piece */
  15. private static int nextId = 0;
  17. /** A Piece must be within this many pixels of "perfect" to be considered
  18.  * close. */
  19. public static final int posClose = 7;
  21. /** A Piece must be within this many degrees of rotation from another to
  22.  * be considered aligned to it. */
  23. public static final int rotClose = 5;
  25. // Constructor and fields -----------------------------------------------
  26. /** Creates a new Piece.  No initial rotation is done.  (This is needed
  27.  * by MultiPiece, which needs to set its subpieces before rotating.)
  28.      * @param data        image data
  29.      * @param imageX      X position of image relative to entire puzzle
  30.      * @param imageY      Y position of image relative to entire puzzle
  31.      * @param imageWidth   width of original image
  32.      * @param imageHeight height of original image
  33.      * @param totalWidth  the width of the entire picture
  34.      * @param totalHeight the height of the entire picture
  35.      */
  36. protected Piece(int[] data, int imageX, int imageY, int imageWidth, int imageHeight, int totalWidth, int totalHeight)
  37. {
  38.  id = nextId++;
  39.  neighbors = new HashSet();
  40.  this.curWidth  = this.origWidth  = imageWidth;
  41.  this.curHeight = this.origHeight = imageHeight;
  42.  origData = data;   
  43.      this.imageX = imageX;
  44.      this.imageY = imageY;
  45.      this.totalWidth = totalWidth;
  46.      this.totalHeight = totalHeight;
  47.    
  48.      // computing hash code:
  49.      if (data != null) {
  50.       int temp = 0;
  51.       for(int i = 0; i < data.length; i++) {
  52.       temp += data[i];
  53.       }
  54.       this.hash = temp;
  55.      } else {
  56.       this.hash = 0;
  57.      }
  58. }
  60. /** Creates a new Piece.
  61.  * @param data        image data
  62.  * @param imageX      X position of image relative to entire puzzle
  63.  * @param imageY      Y position of image relative to entire puzzle
  64.  * @param imageWidth   width of original image
  65.  * @param imageHeight height of original image
  66.  * @param totalWidth  the width of the entire picture
  67.  * @param totalHeight the height of the entire picture
  68.  * @param rotation    initial rotation
  69.  */
  70. public Piece(int[] data, int imageX, int imageY, int imageWidth, int imageHeight, int totalWidth, int totalHeight, int rotation)
  71. {
  72.  this (data, imageX, imageY, imageWidth, imageHeight, totalWidth, totalHeight);
  73.      forceSetRotation (rotation);
  74. }
  76. /**
  77.  * A Copy Constructor.
  78.  * @param p
  79.  */
  80. public Piece(Piece p) {
  81.  this(p.getOrigData(), p.getImageX(), p.getImageY(),
  82.  p.getImageWidth(), p.getImageHeight(), p.getTotalWidth(), p.getTotalHeight(), p.getRotation());
  83. }
  85. /** Piece's unique id. */
  86. protected int id;
  88. /** Location in the image. */
  89.    int imageX, imageY;
  91.    /** Size of the entire image. */
  92.    int totalWidth, totalHeight;
  94.    /** Location in the image adjusted by current rotation. */
  95.    int rotatedX, rotatedY;
  96.  
  97.    /** Pieces considered to be neighbors to this one.  They are the only
  98.     * ones that can be fitted to it.
  99.     */
  100.    protected Set neighbors;
  101.  
  102.    /** Original image size and data. */
  103.    protected int origWidth, origHeight;
  104.    int[] origData;
  105.  
  106.    /** Current size and data, taking rotation into account. */
  107.    protected int curWidth, curHeight;
  108.    int[] curData;
  110.    /** Location in the puzzle panel. */
  111.    int puzzleX, puzzleY;
  113. /** Translation from a piece's upper-left corner to the point last clicked on. */
  114. int transX, transY;
  116. /** constant hash code of the piece. */
  117. protected int hash;
  119.    /** Image for this Piece.  We're going to now try making this null for
  120.     * non-atomic pieces. */
  121.    Image image;
  123.    /** This is measured in integer degrees, 0-359.  0 is unrotated.   
  124.     * 90 is 90 degrees clockwise, etc. */
  125.    int rotation;
  126.  
  127.    // Accessors ------------------------------------------------------------
  128.  
  129.    /** Returns this piece's unique id. */
  130.    public int getId() {return id;}
  131.  
  132.    /** Returns this Piece's current rotation.  The rotation is given in
  133.      * integer degrees clockwise, and will always be between 0 and 359
  134.      * inclusive.
  135.      */
  136.    public int getRotation() { return rotation; }
  137.  
  138.    /** Sets this Piece's current rotation.  The rotation is given in integer
  139.     * degrees clockwise, and should always be between 0 and 359 inclusive.
  140.     * If the new rotation is different, this Piece's image data will be
  141.     * recomputed.
  142.     * @throws IllegalArgumentException if rotation is not in [0,359]
  143.     */
  144.    public void setRotation (int rot)
  145.    {
  146.     if (rot == rotation) return;
  147.     forceSetRotation (rot);
  148.    }
  149.  
  150.    /** Sets this Piece's current rotation.  Unlike setRotation(), this
  151.     * method forces a recompute of the image.
  152.     * @throws IllegalArgumentException if rotation is not in [0,359]
  153.     */
  154.    protected void forceSetRotation (int rot)
  155.    {
  156.     if ((rot < 0) || (rot > 359)) throw new IllegalArgumentException("invalid rotation: "+rot);
  157.     // For now, allow only 0, 90, 180, 270.
  158.     if (rot % 90 != 0) {
  159.      int newRot = rot / 90;
  160.      System.out.println ("unsupported rotation "+rot+"; using "+newRot+" instead" );
  161.      rot = newRot;
  162.     }
  163.     rotation = rot;
  164.     recomputeImageData();
  165.     if (image != null) image.flush();
  166.     image = Toolkit.getDefaultToolkit().createImage (
  167.     new MemoryImageSource (curWidth,curHeight, curData, 0, curWidth));
  168.    }
  169.  
  170.    /** Fulshes the image, unless it is null. */
  171.    public void flushImage() {
  172.     if (image!= null) {
  173.      image.flush();
  174.     }
  175.  image = Toolkit.getDefaultToolkit().createImage (
  176.    new MemoryImageSource (curWidth,curHeight, curData, 0, curWidth));
  177.    }
  178.  
  179.    /** Sets this Piece's upper-left position relative to the upper-left
  180.     *position of the JigsawPuzzle.
  181.     */
  182.    public void setPuzzlePosition (int x, int y)
  183.    {
  184.     this.puzzleX = x;
  185.     this.puzzleY = y;
  186.    }
  187.  
  188.    /** Returns this Piece's current height in pixels.  This is the height of
  189.     * the smallest rectangle containing all of this Piece's image data at
  190.     * its current rotation.
  191.     */
  192.    public int getCurrentHeight() { return curHeight; }
  193.  
  194.    /** Returns this Piece's current width in pixels.  This is the width of
  195.     * the smallest rectangle containing all of this Piece's image data at
  196.     * its current rotation.
  197.     */
  198.    public int getCurrentWidth() { return curWidth; }
  199.  
  200.    /** Returns the width of the entire picture. */
  201.    public int getTotalWidth() { return totalWidth; }
  202.  
  203.    /** Returns the height of the entire picture. */
  204.    public int getTotalHeight() { return totalHeight; }
  205.  
  206.    /** Returns this Piece's image height in pixels.  This is the height of
  207.     * the smallest rectangle containing all of this Piece's image data in
  208.     * its original orientation.
  209.     */
  210.    public int getImageHeight() { return origHeight; }
  211.  
  212.    /** Returns this Piece's image width in pixels.  This is the width of the
  213.     * smallest rectangle containing all of this Piece's image data in its
  214.     * original orientation.
  215.     */
  216.    public int getImageWidth() { return origWidth; }
  217.  
  218.    /** Returns this Piece's X position in the original image. */
  219.    public int getImageX() { return imageX; }
  220.  
  221.    /** Returns this Piece's Y position in the original image. */
  222.    public int getImageY() { return imageY; }
  223.  
  224.    /** Returns this Piece's X position in the original image, modified by
  225.     * its current rotation.  The origin is the center of rotation.  */
  226.    public int getRotatedX() { return rotatedX; }
  227.  
  228.    /** Returns this Piece's Y position in the original image, modified by
  229.     * its current rotation.  The origin is the center of rotation.  */
  230.    public int getRotatedY() { return rotatedY; }
  231.  
  232.    /** Returns this Piece's X position in the original image, modified by
  233.     * the given rotation.  */
  234.    public int getRotatedX(int rotation) { return rotatedX; }
  235.  
  236.    /** Returns this Piece's Y position in the original image, modified by
  237.     * the given rotation.  */
  238.    public int getRotatedY(int rotation) { return rotatedY; }
  239.  
  240.    /** Returns this Piece's X position in the puzzle. */
  241.    public int getPuzzleX() { return puzzleX; }
  242.  
  243.    /** Returns this Piece's Y position in the puzzle. */
  244.    public int getPuzzleY() { return puzzleY; }
  245.  
  246.    /** Returns thie Piece's transX - last pressed X position. */
  247.    public int getTransX() {return transX; }
  248.    public void setTransX(int x) {transX = x;}
  249.  
  250. /** Returns thie Piece's transY - last pressed Y position. */
  251. public int getTransY() {return transY; }
  252. public void setTransY(int y) {transY = y;}
  253.  
  254.    public HashSet getNeighbors() {
  255.     return (HashSet)neighbors;
  256.    }
  257.  
  258.    public void setNeighbors(HashSet neighbors) {
  259.     this.neighbors = neighbors;
  260.    }
  261.    /** Returns this Piece's current image.  This will be the Piece's portion
  262.     * of the original image, rotated by this Piece's current rotation.
  263.     */
  264.    public Image getImage () { return image; }
  265.  
  266.    /** Returns current piece's data */
  267.    public int[] getCurrData() {return curData; }
  268.    public void setCurrData(int[] data) { curData = data; }
  269. /** Returns original piece's data */
  270.    public int[] getOrigData() {
  271.     return this.origData;
  272.    }
  273.    public void setOrigData(int[] data) {
  274.     this.origData = data;
  275.    }
  276.  
  277.    /** Returns a hash value - by the current data */
  278.    public int hashCode() {
  279.     return hash+rotation;
  280.    }
  281.  
  282.  
  283.    /** Adds a Piece to this Piece's set of neighbors.
  284.     * @throws NullPointerException if neighbor is null
  285.     */
  286.    public void addNeighbor (Piece neighbor)
  287.    {
  288.     if (neighbor == null) throw new NullPointerException ("null neighbor" );
  289.     neighbors.add (neighbor);
  290.    }
  291.  
  292.    /** Removes the given Piece from this Piece's set of neighbors. */
  293.    public void removeNeighbor (Piece neighbor)
  294.    {
  295.     neighbors.remove (neighbor);
  296.    }
  297.  
  298.    /** Moves this Piece to the given location, relative to the puzzle
  299.     * panel's upper-left corner.
  300.     */
  301.    public void moveTo (int x, int y)
  302.    {
  303.     setPuzzlePosition (x, y);
  304.    }
  307.  
  308.    /** Draws this Piece in the given Graphics object.  The current image
  309.     * will be drawn, at this Piece's current puzzle position.  */
  310.    protected void draw (Graphics g)
  311.    {
  312.     Image img = getImage();
  313.     if (img != null) g.drawImage (img, getPuzzleX(), getPuzzleY(), null);
  314.    }
  315.  
  316.    /** Returns whether this Piece currently contains the given point,
  317.     * relative to the puzzle panel's upper-left corner.
  318.     */
  319.    public boolean contains (int x, int y)
  320.    {
  321.     int puzX = getPuzzleX();
  322.     int puzY = getPuzzleY();
  323.     int w = getCurrentWidth();
  324.     int h = getCurrentHeight();
  325.  
  326.     return (puzX <= x) && (x <= (puzX+w-1)) && (puzY <= y) && (y <= (puzY+h-1)) &&
  327.         (getAlpha(x-puzX, y-puzY) != 0);
  328.    }
  329.  
  330.    /** Returns the alpha (transparency) value at the given coordinates in
  331.     * the current image data.
  332.     */
  333.    protected int getAlpha (int x, int y)
  334.    {
  335.     int pixel = curData[y*curWidth + x];
  336.     return (pixel >> 24) & 0xff;
  337.    }
  338.  
  339.    /** Returns whether this piece is located and oriented close enough to
  340.     * the given Piece to be fitted.
  341.     */
  342.    public boolean isCloseTo (Piece piece)
  343.    {
  344.     // Check if pieces are aligned
  345.     int rot = getRotation();
  346.     int rotD = Math.abs (piece.getRotation() - getRotation());
  347.     rotD = Math.min (rotD, 360-rotD);
  348.     if (rotD > rotClose) return false;
  349.     // If we're here - pieces are aligned
  350.     int puzXD = getPuzzleX() - piece.getPuzzleX();
  351.     int puzYD = getPuzzleY() - piece.getPuzzleY();
  352.     int rotXD = getRotatedX() - piece.getRotatedX(rot);
  353.     int rotYD = getRotatedY() - piece.getRotatedY(rot);
  354.     return (Math.abs(puzXD-rotXD) <= posClose) && (Math.abs(puzYD-rotYD) <= posClose) ;
  355.  
  356.    }
  357.  
  358.    // Joining pieces -------------------------------------------------------
  359.  
  360.    /** Checks whether any of this Piece's neighbors are located and oriented
  361.     * close enough to be joined to this one.
  362.     * @return an array of Pieces, or null if no neighbors were close enough;
  363.     * if the array is non-null, the first Piece will be the new one;
  364.     * subsequent Pieces will be the ones it was built from
  365.     */
  366.    public Piece[] join ()
  367.    {
  368.     ArrayList close = new ArrayList();
  369.     Iterator iter = neighbors.iterator();
  370.     while (iter.hasNext()) {
  371.      Piece piece = (Piece) iter.next();
  372.      if (piece.isCloseTo (this))
  373.      {
  374.       close.add (piece);
  375.      }
  376.     }
  377.     if (close.size() == 0) return null;
  378.     // We can't just return the new MultiPiece, because the JigsawPuzzle
  379.     // needs to know what pieces the new one was formed from that are
  380.     // currently in its list.  These might include other MultiPieces, which
  381.     // wouldn't be in the new Piece's subpiece list.
  382.     Piece newPiece = MultiPiece.join (this, close);
  383.     Piece[] ret = new Piece[close.size()+2];
  384.     ret[0] = newPiece;
  385.     ret[1] = this;
  386.     this.image.flush();
  387.     for (int i = 0; i < close.size(); i++) {
  388.      Piece piece = (Piece) close.get(i);
  389.      ret[i+2] = piece;
  390.      piece.image.flush();
  391.     }
  392.     System.gc();
  393.     return ret;
  394.    }
  395.  
  396.  
  397.    // 4-way rotation -------------------------------------------------------
  398.    /** Sets this Piece's rotated position and size, based on its current
  399.     * rotation.  The entire puzzle is rotated about the origin, and then
  400.     * translated so that its new upper left corner is at the origin.  Each
  401.     * piece's rotated position is then defined by its new upper left corner
  402.     * in the rotated puzzle.
  403.     */
  404.    protected void setRotatedPosition()
  405.    {
  406.     int rot = getRotation();
  407.     switch (rot) {
  408.      case   0: rotatedX =  imageX; rotatedY =  imageY;
  409.         curWidth = origWidth; curHeight = origHeight;
  410.         break;
  411.      case  90:   rotatedX = totalHeight-imageY-origHeight;
  412.         rotatedY = imageX;
  413.         curWidth = origHeight; curHeight = origWidth;
  414.         break;
  415.      case 180: rotatedX = totalWidth -imageX-origWidth;
  416.         rotatedY = totalHeight-imageY-origHeight;
  417.         curWidth = origWidth; curHeight = origHeight;
  418.         break;
  419.      case 270: rotatedX =  imageY;
  420.         rotatedY = totalWidth -imageX-origWidth;
  421.         curWidth = origHeight; curHeight = origWidth;
  422.         break;
  423.      default:    System.out.println ("sRotPos() can't handle rotation: "+rot);
  424.     }
  425.    }
  426.  
  427.    /** Recomputes this Piece's current image data and size from its original
  428.     * image data and rotation.
  429.     */
  430.    public void recomputeImageData()
  431.    {
  432.     setRotatedPosition();
  433.     if (rotation == 0) {
  434.      curData = (int[]) origData.clone();
  435.     } else if (rotation == 90) {
  436.      curData = new int[origData.length];
  437.      for (int i = 0; i < curWidth; i++) {
  438.       for (int j = 0; j < curHeight; j++) {
  439.        try {
  440.         curData[j*curWidth+i] = origData[(origHeight-i-1)*origWidth + j];
  441.        } catch (ArrayIndexOutOfBoundsException ex) {
  442.         //System.out.println ("ArrayIndexOutOfBoundsException" );
  443.         //System.out.println (" olen="+origData.length+" clen="+curData.length);
  444.         //System.out.println (" i="+i+" j="+j);
  445.         //System.out.println (" orgW="+origWidth+" orgH="+origHeight);
  446.         //System.out.println (" curW="+ curWidth+" curH="+ curHeight);
  447.         //System.out.println (" cIdx="+ (j*curWidth+i)+" oIdx="+ ((origWidth-j-1)*origHeight + i));
  448.         throw new NullPointerException();
  449.        }
  450.       }
  451.      }
  452.     } else if (rotation == 180) {
  453.      curData = new int[origData.length];
  454.      for (int i = 0; i < curWidth; i++) {
  455.       for (int j = 0; j < curHeight; j++) {
  456.        curData[j*curWidth+i] = origData[(origHeight-j-1)*origWidth + (origWidth-i-1)];
  457.       }
  458.      }
  459.     } else if (rotation == 270) {
  460.      curData = new int[origData.length];
  461.      for (int i = 0; i < curWidth; i++) {
  462.       for (int j = 0; j < curHeight; j++) {
  463.        curData[j*curWidth+i] = origData[i*origWidth + (origWidth-j-1)];
  464.       }
  465.      }
  466.     }
  467.      image = Toolkit.getDefaultToolkit().createImage (
  468.      new MemoryImageSource (curWidth,curHeight, curData, 0, curWidth));
  469.    }
  470. }


 
 
 

Code :
  1. public class JigsawPuzzle extends JPanel implements Serializable
  2. {
  3. /**
  4.  * Overriding origianl writeObject.
  5.  * @param out
  6.  * @throws IOException
  7.  */
  8. /*private void writeObject(ObjectOutputStream out) throws IOException {
  9.  Iterator iter = zOrder.iterator();
  10.  while (iter.hasNext()) {
  11.   Piece p = (Piece)iter.next();
  12.   out.writeObject(p);
  13.  }
  14. }*/
  16. /**
  17.  * Overriding original readObject
  18.  * @param in
  19.  * @throws IOException
  20.  * @throws ClassNotFoundException
  21.  */
  22. /*private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
  23.  
  24.  OrderedHashtable zOrder = new OrderedHashtable();
  25.  
  26.  try {
  27.   Piece p;
  28.   while(true) {
  29.    p = (Piece)in.readObject();
  30.    zOrder.put(new Integer(p.getId()), p);
  31.   }
  32.  } catch(OptionalDataException e) {
  33.   // Build the puzzle
  34.   this.image = null;
  35.   this.cutter = null;
  36.   this.zOrder = zOrder;
  37.   setOpaque (true);
  38.   setFocusable(true);
  39.   bgColor = 4;
  40.   setBackground (bgColors[bgColor]);
  41.   setCursor (NORMAL_CURSOR);
  42.   setClearColor();
  43.   addWiring();
  44.   computePreferredSize();
  45.  }  
  46. }*/
  49. // Class constants ------------------------------------------------------
  50. // ### Allow background to be changed.
  51. // ### Allow these to be configured.
  52. // Keyboard commands
  53. public static final char ROTATE_LEFT  = 'E';
  54. public static final char ROTATE_RIGHT = 'R';
  55. public static final char SHUFFLE      = 'S';
  56. public static final char PREV_BG      = 'V';
  57. public static final char NEXT_BG      = 'B';
  58. public static final char CLEAR        = 'C';
  60. // Available background colors
  61. public static final Color[] bgColors = {
  62.  Color.BLACK,
  63.  new Color ( 48,  0,  0),
  64.  new Color (  0, 48,  0),
  65.  new Color (  0,  0, 48),
  66.  new Color ( 48, 48, 48),
  67.  new Color ( 96,  0,  0),
  68.  new Color (  0, 96,  0),
  69.  new Color (  0,  0, 96),
  70.  new Color ( 96, 96, 96),
  71.  new Color (144,  0,  0),
  72.  new Color (  0,144,  0),
  73.  new Color (  0,  0,144),
  74.  new Color (144,144,144),
  75. };
  77. public static final Color CLEAR_COLOR_W = new Color (255,255,255,48);
  78. public static final Color CLEAR_COLOR_B = new Color (  0,  0,  0,48);
  79. public static final Cursor
  80.  NORMAL_CURSOR = new Cursor (Cursor.DEFAULT_CURSOR),
  81.     CLEAR_CURSOR  = new Cursor (Cursor.CROSSHAIR_CURSOR);
  83. // Constructor, fields, and supporting methods --------------------------
  84. /** Creates a new JigsawPuzzle.
  85.  * Implicitly - this is a single player game.
  86.  * @param image the final picture
  87.  * @param cutter the cut to use on the image
  88.  *  
  89.  */
  90. public JigsawPuzzle (Image image, JigsawCutter cutter)
  91. {
  92.  super (false);
  93.  this.image = image;
  94.  this.cutter = cutter;
  95.  this.zOrder = new OrderedHashtable();
  96.  computePreferredSize();
  97.  setOpaque (true);
  98.  setFocusable(true);
  99.  bgColor = 4;
  100.  setBackground (bgColors[bgColor]);
  101.  setCursor (NORMAL_CURSOR);
  102.  setClearColor();
  103.  addWiring();
  104. }
  106. public JigsawPuzzle() {
  107.  super (false);
  108.  this.image = null;
  109.  this.cutter = null;
  110.  this.zOrder = new OrderedHashtable();
  111.  computePreferredSize();
  112.  setOpaque (true);
  113.  setFocusable(true);
  114.  bgColor = 4;
  115.  setBackground (bgColors[bgColor]);
  116.  setCursor (NORMAL_CURSOR);
  117.  setClearColor();
  118.  addWiring();
  119. }
  122. /**
  123.  * Checks if puzzle is ready - in means of having the pieces.
  124.  * @return true = the puzzle is ready (all pieces are cut). false = the puzzle is not ready (has no cut pieces yet).  
  125.  */
  126. public boolean isPuzzleReady() {
  127.  return (!zOrder.isEmpty());
  128. }
  130. public boolean isImageExist() {
  131.  return (image != null);
  132. }
  134. Image image, finishedImage;
  135. JigsawCutter cutter;
  137. Dimension prefSize;
  138. boolean mouseDown = false;
  139. boolean finished  = false;
  140. boolean clearMode = false;
  142. // Last in list = topmost piece
  143. protected OrderedHashtable zOrder;
  145. int bgColor;
  146. int clearX0, clearY0, clearX1, clearY1;
  147. Color clearColor;
  148. int width;
  149. int height;
  150. // If a keyboard command can affect a piece, it'll be this one.
  151. // Typically, this piece should be last in zOrder, but you never know.
  152. Piece focusPiece;
  154. /**
  155.  * To null to focus piece - used after a puzzle is replace
  156.  *
  157.  */
  158. public void nullFocusPiece() {
  159.  focusPiece = null;
  160. }
  162. // Jigsaw Puzzle's properties:
  164. /**
  165.  * Gets the image of the puzzle
  166.  */
  167. public Image getImage() {
  168.  return image;
  169. }
  171. /**
  172.  * Gets the cutter of the puzzle.
  173.  * @return JigsawCutter
  174.  */
  175. public JigsawCutter getCutter() {
  176.  return cutter;
  177. }
  179. /** @return OrderedHashtable of the puzzle's pieces */
  180. public OrderedHashtable getPieces() {
  181.  return zOrder;
  182. }
  185. private void addWiring()
  186. {
  187.  addMouseListener (new MouseAdapter() {
  188.   public void mousePressed (MouseEvent e) {
  189.    JigsawPuzzle.this.requestFocusInWindow();
  190.    mousePressed0 (e);
  191.   }
  192.   public void mouseReleased(MouseEvent e) {
  193.    mouseReleased0(e);
  194.   }
  195.   public void mouseClicked(MouseEvent e) {
  196.    JigsawPuzzle.this.requestFocusInWindow();
  197.   }
  198.  });
  200.  addMouseMotionListener (new MouseMotionAdapter() {
  201.   public void mouseDragged (MouseEvent e) { mouseDragged0 (e); }
  202.  });
  204.  addKeyListener (new KeyAdapter() {
  205.   public void keyTyped (KeyEvent e) { keyTyped0 (e); }
  206.  });
  207. }
  209. // Accessors ------------------------------------------------------------
  210. /** Tells this puzzle to cut the image into pieces and randomize their
  211.  * positions.  This is a potentially time-consuming operation, and should
  212.  * not be done in the AWT thread.
  213.  */
  214. public void reset()
  215. {
  216.  this.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
  217.  // Add progress listener:
  218.  JigsawProgressDialog progressDialog =
  219.   new JigsawProgressDialog((JFrame)this.getTopLevelAncestor(), null);
  220.  CuttingProgress listener = new CuttingProgress(progressDialog);
  221.  cutter.addPieceCreatedListener(listener);
  223.  Thread t = new Thread(new Runnable() {
  224.   public void run() {
  225.    zOrder = null;
  226.    Piece[] pieces = cutter.cut (image);
  227.    shuffle (pieces);
  228.   }
  229.  });
  230.  t.start();
  232.  progressDialog.setString("Création du puzzle..." );
  233.  progressDialog.show();
  235.  // Removing the progress listener:
  236.  cutter.removePieceCreatedListener(listener);
  237.  this.setCursor(null);
  238.  this.repaint();
  239. }
  241. // Event handlers for the cutting process:
  242. private class CuttingProgress implements PieceCreatedListener {
  243.  private JigsawProgressDialog progressDialog;
  245.  public CuttingProgress(JigsawProgressDialog progressDialog) {
  246.   this.progressDialog = progressDialog;
  247.  }
  249.  /**
  250.   * Updates the maximum value of the progress bar
  251.   */
  252.  public void totalPiecesComputed(int totalPieces) {
  253.   progressDialog.setMinimum(0);
  254.   progressDialog.setMaximum(totalPieces);
  255.  }
  257.  /**
  258.   * Advances the progress bar.  
  259.   * In case we reached the end of progress - closes the dialog.
  260.   */
  261.  public void pieceCreated(int currentCreated) {
  262.   progressDialog.setValue(currentCreated);
  264.   if (progressDialog.getValue() >= progressDialog.getMaximum()) {
  265.    progressDialog.hide();
  266.   }
  267.  }
  268. }
  270. /** Move current pieces around randomly, randomize z-order, but don't
  271.  * randomize rotation.
  272.  */
  273. public void shuffle()
  274. {
  275.  Piece[] pieces = new Piece[zOrder.size()];
  276.  zOrder.toArray(pieces);
  277.  shuffle (pieces);
  278.  repaint();
  279. }
  281. // Component methods ----------------------------------------------------
  282. public Dimension getMaximumSize() { return getPreferredSize(); }
  283. public Dimension getMinimumSize() { return getPreferredSize(); }
  284. public Dimension getPreferredSize() { return prefSize; }
  286. /** Returns whether the pieces have been prepared for this puzzle. */
  287. public boolean isCut()
  288. {
  289.  return zOrder != null;
  291. }
  294. protected void paintComponent (Graphics g)
  295. {
  296.  super.paintComponent(g);
  297.  if (zOrder == null) {
  298.   return;
  299.  }
  300.  int x = 0, y = 0;
  301.  Iterator iter = zOrder.iterator();
  302.  while (iter.hasNext()) {
  303.   Piece piece = (Piece) iter.next();
  304.   piece.draw (g);
  305.  }
  306.  if (clearMode && mouseDown) {
  307.   int cx = Math.min (clearX0, clearX1);
  308.   int cy = Math.min (clearY0, clearY1);
  309.   int cw = Math.abs (clearX0-clearX1);
  310.   int ch = Math.abs (clearY0-clearY1);
  311.   g.setColor (clearColor);
  312.   g.fillRect (cx, cy, cw, ch);
  313.  }
  314.  if (finished && (finishedImage != null)) {
  316.   Piece lastPiece = (Piece) zOrder.getFirst();
  317.   x = lastPiece.getPuzzleX();
  318.   y = lastPiece.getPuzzleY();
  319.   g.drawImage (finishedImage, x, y, null);
  320.  }
  321. }
  323. public void setClearMode (boolean flag)
  324. {
  325.  clearMode = flag;
  326.  setCursor (clearMode ? CLEAR_CURSOR : NORMAL_CURSOR);
  327.  // Just in case this is done from outside
  328.  if (!clearMode && mouseDown) clear();
  329. }
  331. // Private methods ------------------------------------------------------
  332. /** Ideally, the preferred area is roughly 1.5 times the area of the
  333.  * image, and the preferred width is 5/3 of the preferred height.
  334.  * However, if the result would be smaller than the image in either
  335.  * dimension, it is enlarged to allow the image to fit.
  336.  */
  337. private void computePreferredSize()
  338. {
  339.  Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
  340.  prefSize = screen;
  341. }
  343. // ### Should this be public?
  344. private void finish()
  345. {
  346.  if (zOrder.size() != 1) return;
  347.  finished = true;
  348.  Piece lastPiece = (Piece) zOrder.getFirst();
  350.  // Auto-rotate the puzzle to its correct position.
  351.  lastPiece.setRotation (0);
  353.  // Center the last piece in the middle of the panel.
  354.  int prevX = lastPiece.getPuzzleX();
  355.  int prevY = lastPiece.getPuzzleY();
  356.  final int width  = lastPiece.getImageWidth();
  357.  final int height = lastPiece.getImageHeight();
  358.  int curW = getWidth();
  359.  int curH = getHeight();
  360.  final int centerX = (curW - width ) / 2;
  361.  final int centerY = (curH - height) / 2;
  362.  lastPiece.moveTo (centerX, centerY);
  363.  repaint(0,   prevX,   prevY, width, height);
  364.  repaint(0, centerX, centerY, width, height);
  366.  // If we have the original image - fade into it - otherwise - finish here:
  367.  if (image == null) {
  368.   return;
  369.  }
  371.  // Draw the original image on top of the last piece in increasing
  372.  // opaqueness.  This should make the pieces appear to fade into the
  373.  // original image.
  374.  final int[] data = new int [width*height];
  375.  try {
  376.   new PixelGrabber(image, 0,0, width, height, data, 0, width).grabPixels();
  377.  } catch (InterruptedException ex) {
  378.   System.out.println ("interrupted on finish grab" );
  379.  }
  381.  for (int i = 0; i < data.length; i++) {
  382.   data[i] = data[i] & 0x00ffffff;
  383.  }
  385.  ActionListener fader = new ActionListener() {
  386.   int trans = 0x00;
  387.   public void actionPerformed (ActionEvent evt) {
  388.    for (int i = 0; i < data.length; i++)
  389.    {
  390.     data[i] = (data[i] & 0x00ffffff) | (trans << 24);
  391.    }
  392.    if (finishedImage != null) finishedImage.flush();
  393.    finishedImage = Toolkit.getDefaultToolkit().createImage (
  394.     new MemoryImageSource (width, height, data, 0, width));
  395.    repaint(0, centerX, centerY, width, height);
  396.    if (trans < 0xff) {
  397.     trans += 0x11;
  398.     if (trans >= 0xff) trans = 0xff;
  399.     Timer timer = new Timer (200, this);
  400.     timer.setRepeats (false);
  401.     timer.start();
  402.    }
  403.   }
  404.  };
  406.  Timer timer = new Timer (200, fader);
  407.  timer.setRepeats (false);
  408.  timer.start();
  409. }
  411. // Mouse event handling -------------------------------------------------
  412. private void mousePressed0 (MouseEvent e)
  413. {
  414.  if (finished) return;
  415.  mouseDown = true;
  416.  if (clearMode) startClearRect(e);
  417.  else grabPiece(e);
  418. }
  420. private void mouseDragged0 (MouseEvent e)
  421. {
  422.  if (finished) return;
  423.  if (clearMode) dragClearRect(e);
  424.  else dragPiece(e);
  425. }
  427. private void mouseReleased0 (MouseEvent e)
  428. {
  429.  if (finished) return;
  430.  mouseDown = false;
  431.  if (clearMode) finishClearRect(e);
  432.  else releasePiece (focusPiece, e);
  433. }
  435. private void grabPiece (MouseEvent e)
  436. {
  437.  int x = e.getX();
  438.  int y = e.getY();
  439.  focusPiece = null;
  440.  ListIterator iter = zOrder.listIterator(zOrder.size());
  441.  while ((focusPiece == null) && (iter.hasPrevious())) {
  442.   Piece piece = (Piece) iter.previous();
  443.   if (piece.contains (x, y)) {
  444.    focusPiece = piece;
  445.    iter.remove();
  446.   }
  447.  }
  448.  if (focusPiece != null) {
  449.   zOrder.put(new Integer(focusPiece.getId()), focusPiece);
  450.   focusPiece.transX = x - focusPiece.getPuzzleX();
  451.   focusPiece.transY = y - focusPiece.getPuzzleY();
  453.   // The focusPiece might have moved up in Z-order.  At worst, we have
  454.   // to repaint its bounding rectangle.
  455.   repaint(0, focusPiece.getPuzzleX(), focusPiece.getPuzzleY(),
  456.     focusPiece.getCurrentWidth(), focusPiece.getCurrentHeight());
  457.  }
  458. }
  460. private void dragPiece (MouseEvent e)
  461. {
  462.  if (focusPiece == null) return;
  463.  int prevX = focusPiece.getPuzzleX();
  464.  int prevY = focusPiece.getPuzzleY();
  465.  int prevW = focusPiece.getCurrentWidth();
  466.  int prevH = focusPiece.getCurrentHeight();
  467.  focusPiece.moveTo (e.getX()-focusPiece.transX, e.getY()-focusPiece.transY);
  468.  // Repaint the focusPiece' previous and current bounding rects.
  469.  repaint(0, prevX, prevY, prevW, prevH);
  470.  repaint(0, focusPiece.getPuzzleX(), focusPiece.getPuzzleY(),
  471.    focusPiece.getCurrentWidth(), focusPiece.getCurrentHeight());
  472. }
  474. public void releasePiece (Piece piece, MouseEvent e)
  475. {
  476.  //System.out.println("In release piece of JigsawPuzzle" );
  477.  if (piece == null) return;
  479.  Piece[] result = piece.join();
  480.  if (result != null) {
  481.   Piece newPiece = result[0];
  482.   for (int i = 1; i < result.length; i++)
  483.   {
  484.    Integer key = new Integer(result[i].getId());
  485.    zOrder.remove(key);
  486.   }
  487.   zOrder.put(new Integer(newPiece.getId()), newPiece);
  488.   focusPiece = newPiece;
  489.   // Joined pieces may be of any size and number.  Mouse release isn't
  490.   // a terribly frequent event, so just repaint the whole thing.  If
  491.   // it's really necessary later, the thing to do would be to repaint
  492.   // the bounding rect for every piece in the result array above.
  493.   repaint();
  494.   if (zOrder.size() == 1) finish();
  495.  }
  496. }
  498. private void startClearRect (MouseEvent e)
  499. {
  500.  clearX0 = e.getX();
  501.  clearY0 = e.getY();
  502. }
  504. private void dragClearRect (MouseEvent e)
  505. {
  506.  int prevX1 = clearX1;
  507.  int prevY1 = clearY1;
  508.  clearX1 = e.getX();
  509.  clearY1 = e.getY();
  510.  int x = Math.min (clearX0, prevX1);
  511.  int y = Math.min (clearY0, prevY1);
  512.  int w = Math.abs (clearX0-prevX1);
  513.  int h = Math.abs (clearY0-prevY1);
  514.  repaint (0, x,y,w,h);
  515.  x = Math.min (clearX0, clearX1);
  516.  y = Math.min (clearY0, clearY1);
  517.  w = Math.abs (clearX0-clearX1);
  518.  h = Math.abs (clearY0-clearY1);
  519.  repaint (0, x,y,w,h);
  520. }
  522. private void finishClearRect (MouseEvent e)
  523. {
  524.  clearX1 = e.getX();
  525.  clearY1 = e.getY();
  526.  int cx0 = Math.max (0, Math.min (clearX0, clearX1));
  527.  int cy0 = Math.max (0, Math.min (clearY0, clearY1));
  528.  int cx1 = Math.min (getWidth(), Math.max (clearX0, clearX1));
  529.  int cy1 = Math.min (getHeight(),Math.max (clearY0, clearY1));
  530.  Iterator iter = zOrder.iterator();
  531.  while (iter.hasNext())
  532.  {
  533.   Piece piece = (Piece) iter.next();
  534.   if (intersects (piece, cx0,cy0,cx1,cy1))
  535.   shuffle (piece, cx0,cy0,cx1,cy1);
  536.  }
  537.  repaint();
  538. }
  540. /** Return whether the piece intersects with the rectangle defined by the
  541.  * given points.  ### Not perfect; returns true for some pieces that it
  542.  * shouldn't.  Ideally, it should grab the part of the Piece in the
  543.  * rectangle, and search it for non-transparent pixels.  Costly, so be
  544.  * careful.
  545.  */
  546. private boolean intersects (Piece piece, int x0, int y0, int x1, int y1)
  547. {
  548.  int px = piece.getPuzzleX();
  549.  int py = piece.getPuzzleY();
  550.  int pw = piece.getCurrentWidth();
  551.  int ph = piece.getCurrentHeight();
  552.  int w = x1 - x0;
  553.  int h = y1 - y0;
  554.  Rectangle r  = new Rectangle (x0,y0,w,h);
  555.  Rectangle rp = new Rectangle (px,py,pw,ph);
  556.  return r.intersects(rp);
  557. }
  559. static final Rectangle emptyRect = new Rectangle (0,0,0,0);
  561. /** Shuffle piece randomly, but keeping it out of the rectangle defined
  562.  * by the given points. */
  563. private void shuffle (Piece piece, int x0, int y0, int x1, int y1)
  564. {
  565.  // Make the rectangle denoting where the Piece could be placed in the
  566.  // whole panel.  Top point will be (0,0).
  567.  int w = getWidth()  - piece.getCurrentWidth();
  568.  int h = getHeight() - piece.getCurrentHeight();
  569.  // If w or h is negative, the piece is too big to be shuffled, so quit.
  570.  if (w<0 || h<0) return;
  572.  // Define the endpoints of the rectangle the Piece must avoid.
  573.  int ax = Math.max (0, x0 - piece.getCurrentWidth());
  574.  int ay = Math.max (0, y0 - piece.getCurrentHeight());
  575.  int ah = y1 - ay;
  577.  // Now define four rectangles forming the shape where the NW piece
  578.  // corner could go.  I'll use BorderLayout rectangles as a guide.
  579.  Rectangle north = (ay==0) ? emptyRect : new Rectangle (0,0, w, ay);
  580.  Rectangle south = (y1>=h) ? emptyRect : new Rectangle (0,y1+1, w, h-y1);
  581.  Rectangle west  = (ax==0 || ah==0) ? emptyRect : new Rectangle (0,ay, ax,ah);
  582.  Rectangle east  = (x1>=w || ah==0) ? emptyRect : new Rectangle (x1,ay, w-x1,ah);
  584.  int nArea = north.width * north.height, sArea = south.width * south.height,
  585.   wArea = west .width * west .height,
  586.   eArea = east .width * east .height,
  587.   totalArea = nArea + sArea + wArea + eArea;
  589.  int rand = (int) (Math.random() * totalArea);
  590.  rand -= nArea; if (rand<0) { shuffle (piece,north); return; }
  591.      rand -= sArea; if (rand<0) { shuffle (piece,south); return; }
  592.      rand -= wArea; if (rand<0) { shuffle (piece,west ); return; }
  593.      shuffle (piece,east );
  594. }
  596. private void shuffle (Piece piece, Rectangle rect)
  597. {
  598.  int dx = (int) (Math.random() * rect.width);
  599.  int dy = (int) (Math.random() * rect.height);
  600.  piece.moveTo (rect.x+dx, rect.y+dy);
  601. }
  603. // Keyboard event handling ----------------------------------------------
  604. public void keyTyped0 (KeyEvent e)
  605. {
  606.  if (finished) return;
  607.  char ch = Character.toUpperCase (e.getKeyChar());
  608.  if (ch==ROTATE_LEFT) {
  609.   rotatePiece (focusPiece, 270);
  610.  }
  611.  else if (ch==ROTATE_RIGHT) {
  612.   rotatePiece (focusPiece, 90);
  613.  }
  614.  else if (ch==PREV_BG)      prevBackground();
  615.  else if (ch==NEXT_BG)      nextBackground();
  616.  // The following features are disabled when playing multi-players game
  617.  else if (ch==CLEAR) toggleClearMode();
  618.  else if (ch==SHUFFLE) shuffle();
  619.  else return;
  620. }
  624. public Piece findPiece(int pieceId) {
  625.  Piece remoteFocusPiece=null;
  626.  Iterator iter = zOrder.iterator();
  627.  while(iter.hasNext()) {
  628.   remoteFocusPiece = (Piece)iter.next();
  629.   if (remoteFocusPiece.getId()==pieceId) {
  630.    // Piece Found
  631.    return remoteFocusPiece;
  632.   }
  633.  }
  634.  return null;
  635. }
  637. public void rotatePiece (Piece piece, int amount)
  638. {
  639.  if (piece == null) return;
  640.  int newRotation = piece.getRotation()+amount;
  641.  newRotation %= 360;
  642.  int prevW = piece.getCurrentWidth();
  643.  int prevH = piece.getCurrentHeight();
  644.  int prevX = piece.getPuzzleX();
  645.  int prevY = piece.getPuzzleY();
  646.  piece.setRotation (newRotation);
  647.      // Make the piece appear to rotate about its center.
  648.      // ### Feature: When the mouse is down, rotate about the cursor instead
  649.      //   of the center.
  650.      int centerX = prevX + prevW/2;
  651.      int centerY = prevY + prevH/2;
  652.      int currW = piece.getCurrentWidth();
  653.      int currH = piece.getCurrentHeight();
  654.      int currX = centerX - currW/2;
  655.      int currY = centerY - currH/2;
  656.      piece.moveTo (currX, currY);
  657.      repaint(0, prevX, prevY, prevW, prevH);
  658.      repaint(0, currX, currY, currW, currH);
  659. }
  661. private void shuffle(Piece[] pieces)
  662. {
  663.  zOrder = null;
  665.  // Copy pieces in random order into zOrder, and randomize their
  666.  // positions.
  667.  OrderedHashtable zOrder0 = new OrderedHashtable();
  668.  int lastIdx = pieces.length-1;
  669.  while (lastIdx > 0) {
  670.   int pIdx = (int) (Math.random() * (lastIdx+1));
  671.   Piece piece = pieces[pIdx];
  672.   piece.setPuzzlePosition ((int) (Math.random() * (width  - piece.getCurrentWidth())) ,
  673.         (int)  (Math.random() * (height - piece.getCurrentHeight())) );
  674.   zOrder0.put(new Integer(piece.getId()), piece);
  675.   if (pIdx != lastIdx) {
  676.    Piece temp = pieces[lastIdx];
  677.    pieces[lastIdx] = pieces[pIdx];
  678.    pieces[pIdx] = temp;
  679.   }
  680.   lastIdx--;
  681.  }
  682.  zOrder0.put(new Integer(pieces[0].getId()), pieces[0]);
  683.  finished = false;
  684.  if (finishedImage != null) {
  685.   finishedImage.flush();
  686.   finishedImage = null;
  687.  }
  689.  zOrder = zOrder0;
  690. }
  692. private void prevBackground()
  693. {
  694.  bgColor--;
  695.  if (bgColor < 0) bgColor = bgColors.length-1;
  696.  setBackground (bgColors[bgColor]);
  697.  setClearColor();
  698.  repaint();
  699. }
  701. private void nextBackground()
  702. {
  703.  bgColor++;
  704.  if (bgColor >= bgColors.length) bgColor = 0;
  705.  setBackground (bgColors[bgColor]);
  706.  setClearColor();
  707.  repaint();
  708. }
  710. private void toggleClearMode()
  711. {
  712.  if (mouseDown) return; // can't toggle clear mode while dragging
  713.  setClearMode (!clearMode);
  714. }
  716. private void clear()
  717. {
  718.  // ### stub
  719. }
  721. private void setClearColor()
  722. { clearColor = getClearColor(); }
  724. private Color getClearColor()
  725. { return isBright (bgColors[bgColor]) ? CLEAR_COLOR_B : CLEAR_COLOR_W; }
  727. private boolean isBright (Color c)
  728. {
  729.  float[] hsb = new float[3];
  730.  Color.RGBtoHSB (c.getRed(),c.getGreen(),c.getBlue(), hsb);
  731.  return hsb[2] > 0.5;
  732. }
  734.     /**
  735.      * Retrieves a piece of the puzzle
  736.      * @param key The piece's key - of the piece to retrieve
  737.      * @return Returns the appropraite piece reference - or null, if no piece with the specified key was found.
  738.      */
  739.     public Piece getPiece(int key) {
  740.      Piece p = (Piece)zOrder.get(new Integer(key));
  741.         return p;
  742.     }
  744. public void setHeight(int height) {
  745.  this.height= height;
  746. }
  748. public void setWidth(int width) {
  749.  this.width = width;
  750. }
  752. }

mood
Publicité
Posté le 15-05-2011 à 16:16:46  profilanswer
 

n°2076105
olivthill
Posté le 16-05-2011 à 10:17:40  profilanswer
 

Le coeur de l'algorithme se trouve dans les lignes suivantes

Citation :

while (iter.hasNext()) {
     Piece piece = (Piece) iter.next();
     if (piece.isCloseTo (this))
     {
      close.add (piece);
     }


Il y a une boucle sur toutes les pièces voisines potentielles. Celle qui convient (voir le code de isCloseTo) est celle avec qui la jointure est effectuée.


Aller à :
Ajouter une réponse
  FORUM HardWare.fr
  Programmation
  Java

  aidez moi svp dans la compréhension de ce code

 

Sujets relatifs
Sauvegarde fichier mon code n'est pas parfaitcode pour le calcul d'une fonction à partir d'une matrice
Zone texte html agissant sur code sourceException code in C ???
Code C-Lecture de fichiers à partir d'un dossier.Creation d'une appli Web a partir du code C# Winforms
Transformer ma fonction Recherche en codeDecouper un code recursif
Code VBA WordLe Google Summer of Code
Plus de sujets relatifs à : aidez moi svp dans la compréhension de ce code

Forum MesDiscussions.Net, Version 2010.2
(c) 2000-2011 Doctissimo
Page générée en 0.325 secondes

Copyright © 1997-2022 Hardware.fr SARL (Signaler un contenu illicite / Données personnelles) / Groupe LDLC / Shop HFR