Measuring the Warpage of a PCB

This application example is provided as a C++ sample program, named 3DPCBWarpage:

Note: To run this program, you need the Easy3D and EasyGauge licenses.

Display output of the 3D PCB Warpage application example

Note: The calibration process is not described in this document. We assume that a calibration has been done and that the metric unit used is the mm.

This application demonstrates how to measure the warpage of a PCB.

In this application, we define the warpage as the difference between the highest and the lowest surface points when the PCB regression plane is oriented horizontally. In other words, we fit a plane through the PCB points and take the perpendicular distance between the highest point above and the lowest point below this regression plane.

The main steps of the process are:

For the generation of the final ZMap, the application will fit a regression plane through the remaining / filtered data.

The (optional) alignment on the PCB edges ensures that the resulting ZMap is always the same, independently of the orientation of the PCB during the measurement.

Moreover, on the final ZMap, the horizon is parallel with the PCB regression plane. This is necessary to have a well-defined warpage value.

Alternatively, you can load directly a point cloud from a file.

This step produces a reference plane called refPlane_1 of the type E3DPlane.

The following image shows this first ZMap with a 16-bit per pixel resolution.

In this image:

Because the reference plane of the ZMap is 10 mm below the PCB, the average gray value in the image is 10000 (10000 gray values = 10000 µm).

On the ZMap, the application should ignore the following points during the computation of the warpage:

The application removes points and applies a low-pass filter on the remaining points to detect only the slow / global PCB deformations. This filtering is done in 2 steps.

Filter 1: removing the outliers

The filter condition used here is E3DNoiseRemovalMethod_AbsoluteDifferenceFromMean; it compares the value of the pixel in the center with the average of all valid pixels in the kernel window.

This is illustrated on the figure below.

The application evaluates the condition to keep or remove the center pixel as follow :

Filter 2: applying an averaging filter

Filtering code

The code used for the filtering of the ZMap data is:

// Process the ZMap to remove noise and small scale structures
// Filters parameters
int halfKernelSizeFilter = 25; // kernel size = 2 x halfKernelSizeFilter + 1 pixel = 51
float thresholdFilter = 0.030f; // threshold = maximum deviation from mean
float ratioValidPixelsFilter = 0.25f; // requires at least 25% of valid points in the kernel
 
// Apply noise removal filter
EZMap16 zmapBeforeAlignmentFilter1; // output of the filter
zmapBeforeAlignmentFilter1.SetSize(zmapBeforeAlignment);
Easy3D::RemoveNoise(zmapBeforeAlignment, zmapBeforeAlignmentFilter1,
                    E3DNoiseRemovalMethod_AbsoluteDifferenceFromMean, 
                    halfKernelSizeFilter, thresholdFilter, ratioValidPixelsFilter, false);
 
// Apply low-pass filter
EZMap16 zmapBeforeAlignmentFilter2; // output of the second filter
zmapBeforeAlignmentFilter2.SetSize(zmapBeforeAlignment);
Easy3D::ComputeAverageMap(zmapBeforeAlignmentFilter1, zmapBeforeAlignmentFilter2,
                          halfKernelSizeFilter, ratioValidPixelsFilter);

The different steps of the filtering are illustrated below:

The 2 steps of the ZMap filtering

This optional step consists in finding the orientation of the PCB (detection of a rectangle).

We could skip this step for the computation of the warpage but aligning on the edges makes the comparison of different ZMaps with each other easier.

To generate a ZMap aligned on the PCB edges:

The application uses the transitions between the undefined (0) and the valid (non-zero) pixels to detect the position of the edges of the rectangle.

The use of a rectangular gauge on the ZMap image is illustrated below:

In the code below, the filtered point cloud is named filteredPc:

// From the filtered ZMap, generate a new 3D point cloud
// Use that point cloud to estimate a better reference plane
E3DPointCloud filteredPc;
zmapBeforeAlignmentFilter2.ToPointCloud(filteredPc);
E3DPlaneFitter planeFitter;
E3DPlane refPlane_2 = planeFitter.Fit(filteredPc);  // find the best fit plane

This plane is much less sensitive to the noise and outliers found in the original data.

The position of this new ZMap is based on:

The code that generates this aligned ZMap is:

// Generate the new ZMap with the filtered data
EZMap16 zmap_;
zmapGenerator.SetOrigin(corner_3D[2]);
zmapGenerator.SetReferencePlane(refPlane_2 - zMapOffset); // refPlane_2 – 10mm
E3DPoint horizDirection(corner_3D[1].X - corner_3D[0].X,
                        corner_3D[1].Y - corner_3D[0].Y,
                        corner_3D[1].Z - corner_3D[0].Z);
zmapGenerator.SetOrientationVector(horizDirection);
zmapGenerator.SetResolution((int)rectangleSizeX, (int)rectangleSizeY);
zmapGenerator.SetExtension(0.f); // no border
zmapGenerator.Convert(filteredPc, zmap_);

It retrieves these values with the static method ComputeStatistics in the class Easy3D.

The corresponding code is:

// Calculate warpage in metric unit
UINT32 validCount;
float minValue, maxValue, averageValue;
Easy3D::ComputeStatistics(zmap_, validCount, minValue, maxValue, averageValue);
float warpage = maxValue - minValue;

Sample 3D renderings of the resulting depth maps (showing the warpage) and their corresponding warpage measurement are illustrated below:

Warpage = 0.145 mm