The project is in progress. The core design is based on STDF V4 format.

• Use maxX, maxY, minX, minY to setup the die size in canvas.
• No need to has the result of all (x,y).

1. Install rollup.js package.

npm install -g rollup

2. Change to the project directory and install dependencies modules.

npm install

3. Build the project and output the result to dist/uia-wafermap.js.

npm run build

• graphics coordination from TopLeft(0,0) to BottomRight(row,col) (NOT die coordination)
• layers

// create a shotmap
var shotmap = uia.shotmap('wafer2')         // element id
    .size(600, 10)                          // size of canvas
    .notch("down")                          // notch direction
    .wheel(true)                            // use the wheel to control zoom in & out 
    .drag(true)                             // drag and drop the map
    .diePalette(function(value) {           // color palette, the value passed from result function.
      switch(value) {
        case 0:                             // pass
          return 0x00ff00;                  // green
        case 1:                             // fail
          return 0xff0000;                  // red
        case 2:                             // good to bad
          return 0xff0000;                  // red
        default:                            // unknown
          return 0xffffff;                  // white
      }
    })

// bind data to the shotmap
var data = shotmap.data(101, 98, 1, 1)      // maxRow, maxCol, minRow, minCol, origin="leftdown", pickMode="testing"
    .layer("1", 0, layerData)               // layer #1, all good, dataset
    .layer("2", 1, layerData)               // layer #2, all bad, dataset
    .layer("3", layer3result, layerData);   // layer #3, random result, dataset

data.layer("2").enabled(false);             // disable layer #2

shotmap.create(true);                       // create a map with boundary checking. 

function layer3result() {                   // random result of layer 3
  return Math.random() > 0.2 ? 0 : 1;       
}  

function layerData(row, col) {              // information of a die
  return ""   row    ","   col;
}  

The output:

Use blue to identify good to bad test results.

var shotmap = uia.shotmap('wafer2')
    .size(600, 10)
    .notch("down")
    .wheel(false)
    .drag(false)
    .diePalette(function(value) { 
      switch(value) {
        case 0:
          return 0x00ff00;
        case 1:
          return 0xff0000;
        case 2:
          return 0x0000ff;  // from good to bad
        default:
          return 0xffffff;
      }
    })
    .attachClick(function(oEvent) {         // click event of the die
      alert(oEvent.pick()[0]);
    })

The output:

• attachClick (function clickHandler)

  pickerFunc = function({
    source: Die,
    data: WaferData,
    pick: function()
  }) {
  
  }

• blocking (int blur = 9, int bg = null)

  • The blur argument of OpenCV.js.
  • The background color, ex: 0x00ff00.

• create (boolean checkBounding)

• data (int maxX, int maxY, int minX = 1, int maxY = 1, string origin = "leftdown", string pickMode = "testing"): WaferData

  The origin is one of leftdown, leftup, rightdown and rightup.

  The pickMode is one of testing and counting.

  • testing - check if a die is pass or not.
  • counting - count the failure of number.
  • bincode - bincode tracing.

• dieRect (boolean enabled)

• diePalette (function pickerFunc)

  pickerFunc = function(int value) {
    return color;
  }

• drag (boolean enabled)

• draw (boolean enabled))

• extract (string type)

  • canvas - output canvas object.
  • image - output HTML image object.

• notch (string direction)

• reset ()

• size (int diameter, int margin = 10)

• wheel (boolean enabled)

• zoomIn (int offsetX, int offsetY)

• zoomOut (int offsetX, int offsetY)

• layer (string id, function resultTester, function dataPicker): Layer

  /**
   * @return the result will be passed to the pickMode method.
   */
  resultTester = function(int rowOffset, int colOffset) {
    return 0;
  }
  
  dataPicker = function(int rowOffset, int colOffset) {
    return any;
  }

• mode (string mode) mode is one of counting and testing.

• enabled (boolean enabled)

When you create a waferdata using shotmap.data(101, 98, 1, 1, "leftdown", pickMode), the last argument pickMode is used to re-explain die results from all layers and return a new meaning value to the color selector.

The workflow likes: layerResult(*) >>> pickMode method >>> diePalette.

/**
 * @value passed from pickMode method.
 */
var shotmap = uia.shotmap('wafer2')         
    .diePalette(function(value) {
        // pickMode: testing
        switch (value) {
            case 0: // green
                return 0x00ff00;
            case 1: // red
                return 0xff0000;
            case 2: // yellow
                return 0xffff00;
            case 3: // blue
                return 0x0000ff;
            default:
                return 0xffffff;
        }
    });

shotmap.data(101, 98, 1, 1, "leftdown", "testing")
    .layer("1", layerResult1, layerData)
    .layer("2", layerResult2, layerData);

The pickMode is one of follow:

• testing - /src/waferdata/testing.js

  The main scenario is used to show merged results of one wafer, and the value layerResult provides always be one of -1(NA), 0(good) and 1(failed).

  • -1: N/A
  • 0: pass
  • 1: bad
  • 2: good - bad
  • 3: good - good

• counting - /src/waferdata/counting.js

  The main scenario is used to count failed number of multi wafers, and the value layerResult provides always be one of -1(NA), 0(good) and 1(failed).

  • -1: N/A
  • 0: no failed
  • 1~n: failed count

• bincode - /src/waferdata/bincode.js

  The main scenario is used to display failed information, and the value layerResult provides will be -1(NA), 0(good) or others number(failed bin code).

  Check the example7.html.

  • -1: N/A
  • 0: all good
  • 1~n: first none zero value(bin code)

1. notch (x, y) offset.
2. confusing coordination.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.