public GridInterpolation(RTrackCell [,] g, double cellsize, SySal.BasicTypes.Rectangle refrect, int minmatches)
{
m_Grid = g;
CellSize = cellsize;
RefRect = refrect;
SySal.BasicTypes.Vector2 c = new SySal.BasicTypes.Vector2();
c.X = 0.5 * (refrect.MinX + RefRect.MaxX);
c.Y = 0.5 * (refrect.MinY + RefRect.MaxY);
XCells = m_Grid.GetLength(0);
YCells = m_Grid.GetLength(1);
MinMatches = minmatches;
MaxXYCells = Math.Max(XCells, YCells);
m_Grid2 = new RTrackCell[XCells, YCells];
int ix, iy;
for (ix = 0; ix < XCells; ix++)
{
for (iy = 0; iy < YCells; iy++)
{
RTrackCell rrc = m_Grid[ix, iy];
RTrackCell rtc = new RTrackCell(rrc.Extents, c);
m_Grid2[ix, iy] = rtc;
m_Grid2[ix, iy].Average = rtc.Center;
rtc.Result = NumericalTools.ComputationResult.OK;
rtc.Matches = Math.Max(minmatches, rrc.Matches);
SySal.BasicTypes.Vector v = new SySal.BasicTypes.Vector();
EvaluateW(rtc.Center.X, rtc.Center.Y, ref v, ref rtc.AlignInfo);
rtc.SlopeAlignInfo.X = v.X;
rtc.SlopeAlignInfo.Y = v.Y;
}
}
}
public Writer(string filepath, SySal.BasicTypes.Identifier id, SySal.BasicTypes.Rectangle extents, SySal.BasicTypes.Vector2 center, SySal.DAQSystem.Scanning.IntercalibrationInfo transform)
{
guid = System.Environment.ExpandEnvironmentVariables("%TEMP%\\" + System.Guid.NewGuid().ToString() + ".tlgs.");
m_FilePath = filepath;
w_tlg = new System.IO.BinaryWriter(new System.IO.FileStream(filepath, System.IO.FileMode.Create, System.IO.FileAccess.Write, System.IO.FileShare.None));
b_toptk = new System.IO.BinaryWriter(t_toptk = new System.IO.FileStream(guid + "ttk", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None));
b_bottk = new System.IO.BinaryWriter(t_bottk = new System.IO.FileStream(guid + "btk", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None));
b_topvw = new System.IO.BinaryWriter(t_topvw = new System.IO.FileStream(guid + "tvw", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None));
b_botvw = new System.IO.BinaryWriter(t_botvw = new System.IO.FileStream(guid + "bvw", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None));
b_topix = new System.IO.BinaryWriter(t_topix = new System.IO.FileStream(guid + "tix", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None));
b_botix = new System.IO.BinaryWriter(t_botix = new System.IO.FileStream(guid + "bix", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None));
b_linked = new System.IO.BinaryWriter(t_linked = new System.IO.FileStream(guid + "lk", System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None));
w_tlg.Write((byte)0x41);
w_tlg.Write((ushort)0x7);
w_tlg.Write(SectionTag);
Section_Tracks_pos = w_tlg.BaseStream.Position;
w_tlg.Write((long)0);
w_tlg.Write(id.Part0);
w_tlg.Write(id.Part1);
w_tlg.Write(id.Part2);
w_tlg.Write(id.Part3);
w_tlg.Write(center.X);
w_tlg.Write(center.Y);
w_tlg.Write(extents.MinX);
w_tlg.Write(extents.MaxX);
w_tlg.Write(extents.MinY);
w_tlg.Write(extents.MaxY);
w_tlg.Write(transform.MXX);
w_tlg.Write(transform.MXY);
w_tlg.Write(transform.MYX);
w_tlg.Write(transform.MYY);
w_tlg.Write(transform.TX);
w_tlg.Write(transform.TY);
w_tlg.Write(transform.RX);
w_tlg.Write(transform.RY);
}
public RTrackCell(SySal.BasicTypes.Rectangle rect, SySal.BasicTypes.Vector2 gencenter)
{
Extents = rect;
Center.X = 0.5 * (rect.MinX + rect.MaxX);
Center.Y = 0.5 * (rect.MinY + rect.MaxY);
FName = System.Environment.GetEnvironmentVariable("TEMP");
if (FName.EndsWith("/") == false && FName.EndsWith("\\") == false)
{
FName += "/";
}
FName += "flattentlg_" + System.Guid.NewGuid().ToString() + ".tmp";
TempStream = new System.IO.FileStream(FName, System.IO.FileMode.Create, System.IO.FileAccess.ReadWrite);
Count = 0;
TempWrite = new System.IO.BinaryWriter(TempStream);
TempRead = new System.IO.BinaryReader(TempStream);
Sum.X = 0.0;
Sum.Y = 0.0;
Average.X = 0.0;
Average.Y = 0.0;
AlignInfo.RX = Center.X; //gencenter.X;
AlignInfo.RY = Center.Y; //gencenter.Y;
}
/// <summary>
/// Maps a pattern of tracks onto another one.
/// </summary>
/// <param name="refpattern">the reference pattern.</param>
/// <param name="mappattern">the pattern to be mapped.</param>
/// <param name="flt">the filter function for mapping.</param>
/// <param name="logstrw">the output stream where logging information is written; set to <c>null</c> to disable logging.</param>
/// <returns>the transformation obtained.</returns>
public SySal.DAQSystem.Scanning.IntercalibrationInfo MapTransform(SySal.Tracking.MIPEmulsionTrackInfo[] refpattern, SySal.Tracking.MIPEmulsionTrackInfo[] mappattern, MapManager.dMapFilter flt, System.IO.TextWriter logstrw)
{
SySal.DAQSystem.Scanning.IntercalibrationInfo calinfo = new SySal.DAQSystem.Scanning.IntercalibrationInfo();
try
{
if (logstrw != null)
{
logstrw.WriteLine("Begin pattern mapping.");
}
calinfo.MXX = calinfo.MYY = 1.0;
calinfo.MXY = calinfo.MYX = 0.0;
calinfo.RX = calinfo.RY = calinfo.TX = calinfo.TY = calinfo.TZ = 0.0;
int nr = refpattern.Length;
int na = mappattern.Length;
if (logstrw != null)
{
logstrw.WriteLine("Ref tracks: " + nr);
logstrw.WriteLine("Add tracks: " + na);
}
if (nr == 0 || na == 0)
{
return(calinfo);
}
SySal.BasicTypes.Rectangle refrect = new SySal.BasicTypes.Rectangle();
SySal.BasicTypes.Rectangle addrect = new SySal.BasicTypes.Rectangle();
SySal.Tracking.MIPEmulsionTrackInfo refinfo = refpattern[0];
SySal.Tracking.MIPEmulsionTrackInfo addinfo = mappattern[0];
refrect.MinX = refrect.MaxX = refinfo.Intercept.X;
refrect.MinY = refrect.MaxY = refinfo.Intercept.Y;
addrect.MinX = addrect.MaxX = addinfo.Intercept.X;
addrect.MinY = addrect.MaxY = addinfo.Intercept.Y;
int i;
for (i = 1; i < nr; i++)
{
refinfo = refpattern[i];
if (refinfo.Intercept.X < refrect.MinX)
{
refrect.MinX = refinfo.Intercept.X;
}
else if (refinfo.Intercept.X > refrect.MaxX)
{
refrect.MaxX = refinfo.Intercept.X;
}
if (refinfo.Intercept.Y < refrect.MinY)
{
refrect.MinY = refinfo.Intercept.Y;
}
else if (refinfo.Intercept.Y > refrect.MaxY)
{
refrect.MaxY = refinfo.Intercept.Y;
}
}
for (i = 1; i < na; i++)
{
addinfo = mappattern[i];
if (addinfo.Intercept.X < addrect.MinX)
{
addrect.MinX = addinfo.Intercept.X;
}
else if (addinfo.Intercept.X > addrect.MaxX)
{
addrect.MaxX = addinfo.Intercept.X;
}
if (addinfo.Intercept.Y < addrect.MinY)
{
addrect.MinY = addinfo.Intercept.Y;
}
else if (addinfo.Intercept.Y > addrect.MaxY)
{
addrect.MaxY = addinfo.Intercept.Y;
}
}
SySal.BasicTypes.Rectangle maprect = new SySal.BasicTypes.Rectangle();
maprect.MinX = Math.Max(refrect.MinX, addrect.MinX);
maprect.MaxX = Math.Min(refrect.MaxX, addrect.MaxX);
maprect.MinY = Math.Max(refrect.MinY, addrect.MinY);
maprect.MaxY = Math.Min(refrect.MaxY, addrect.MaxY);
int xcells = (int)Math.Ceiling((maprect.MaxX - maprect.MinX) / m_Config.MapSize);
int ycells = (int)Math.Ceiling((maprect.MaxY - maprect.MinY) / m_Config.MapSize);
if (logstrw != null)
{
logstrw.WriteLine("Ref rect: " + refrect.MinX + " " + refrect.MaxX + " " + refrect.MinY + " " + refrect.MaxY);
logstrw.WriteLine("Map rect: " + addrect.MinX + " " + addrect.MaxX + " " + addrect.MinY + " " + addrect.MaxY);
logstrw.WriteLine("Common rect: " + maprect.MinX + " " + maprect.MaxX + " " + maprect.MinY + " " + maprect.MaxY);
logstrw.WriteLine("X cells: " + xcells + " Y cells: " + ycells);
}
if (xcells <= 0 || ycells <= 0)
{
return(calinfo);
}
int ix, iy;
System.Collections.ArrayList[,] rmaps = new System.Collections.ArrayList[ycells, xcells];
System.Collections.ArrayList[,] amaps = new System.Collections.ArrayList[ycells, xcells];
for (ix = 0; ix < xcells; ix++)
{
for (iy = 0; iy < ycells; iy++)
{
rmaps[iy, ix] = new System.Collections.ArrayList();
amaps[iy, ix] = new System.Collections.ArrayList();
}
}
for (i = 0; i < nr; i++)
{
refinfo = refpattern[i];
ix = (int)((refinfo.Intercept.X - maprect.MinX) / m_Config.MapSize);
if (ix < 0 || ix >= xcells)
{
continue;
}
iy = (int)((refinfo.Intercept.Y - maprect.MinY) / m_Config.MapSize);
if (iy < 0 || iy >= ycells)
{
continue;
}
if (flt == null || flt(refinfo))
{
rmaps[iy, ix].Add(refinfo);
}
}
for (i = 0; i < na; i++)
{
addinfo = mappattern[i];
ix = (int)((addinfo.Intercept.X - maprect.MinX) / m_Config.MapSize);
if (ix < 0 || ix >= xcells)
{
continue;
}
iy = (int)((addinfo.Intercept.Y - maprect.MinY) / m_Config.MapSize);
if (iy < 0 || iy >= ycells)
{
continue;
}
if (flt == null || flt(addinfo))
{
amaps[iy, ix].Add(addinfo);
}
}
System.Collections.ArrayList mres = new System.Collections.ArrayList();
for (ix = 0; ix < xcells; ix++)
{
for (iy = 0; iy < ycells; iy++)
{
SySal.Tracking.MIPEmulsionTrackInfo[] ri = (SySal.Tracking.MIPEmulsionTrackInfo[])rmaps[iy, ix].ToArray(typeof(SySal.Tracking.MIPEmulsionTrackInfo));
if (ri.Length <= 0)
{
continue;
}
SySal.Tracking.MIPEmulsionTrackInfo[] ai = (SySal.Tracking.MIPEmulsionTrackInfo[])amaps[iy, ix].ToArray(typeof(SySal.Tracking.MIPEmulsionTrackInfo));
if (ai.Length <= 0)
{
continue;
}
MapResult mr = Map(ri, ai)[0];
if (mr.Valid)
{
SySal.BasicTypes.Vector2 p = new SySal.BasicTypes.Vector2();
p.X = maprect.MinX + m_Config.MapSize * (ix + 0.5);
p.Y = maprect.MinY + m_Config.MapSize * (iy + 0.5);
mres.Add(new object[] { p, mr });
logstrw.WriteLine("Z ix " + ix + " iy " + iy + " matches " + mr.Matches + " X " + p.X + " Y " + p.Y + " DeltaX/Y " + mr.DeltaPos.X + "/" + mr.DeltaPos.Y + " RMSX/Y " + mr.DeltaPosRMS.X + "/" + mr.DeltaPosRMS.Y + " DeltaSX/Y " + mr.DeltaSlope.X + "/" + mr.DeltaSlope.Y + " RMSX/Y " + mr.DeltaSlopeRMS.X + "/" + mr.DeltaSlopeRMS.Y);
}
else if (logstrw != null)
{
logstrw.WriteLine("Z ix " + ix + " iy " + iy + " matches " + mr.Matches);
}
}
}
double[,] inXY = new double[mres.Count, 2];
double[,] dXY = new double[mres.Count, 2];
for (i = 0; i < mres.Count; i++)
{
object[] o = (object[])mres[i];
inXY[i, 0] = ((SySal.BasicTypes.Vector2)o[0]).X;
inXY[i, 1] = ((SySal.BasicTypes.Vector2)o[0]).Y;
dXY[i, 0] = -((MapResult)o[1]).DeltaPos.X;
dXY[i, 1] = -((MapResult)o[1]).DeltaPos.Y;
if (logstrw != null)
{
logstrw.WriteLine("Zone " + i + " matches " + ((MapResult)o[1]).Matches + " " + inXY[i, 0] + " " + inXY[i, 1] + " " + dXY[i, 0] + " " + dXY[i, 1]);
}
}
switch (mres.Count)
{
case 0: return(calinfo);
case 1: return(calinfo = TransformFitter.FindTranslation(inXY, dXY));
case 2: return(calinfo = TransformFitter.FindRototranslation(inXY, dXY));
default:
try
{
return(calinfo = TransformFitter.FindAffineTransformation(inXY, dXY));
}
catch (Exception)
{
return(calinfo = TransformFitter.FindRototranslation(inXY, dXY));
}
}
}
finally
{
if (logstrw != null)
{
logstrw.WriteLine("End mapping with RX/Y " + calinfo.RX + "/" + calinfo.RY + " MXX/XY/YX/YY " + calinfo.MXX + "/" + calinfo.MXY + "/" + calinfo.MYX + "/" + calinfo.MYY + " TX/Y " + calinfo.TX + "/" + calinfo.TY + ".");
}
}
}
/// <summary>
/// Extracts a track map from the data.
/// </summary>
/// <param name="data">the input data; can be an array of microtracks, a linked zone or a TotalScan volume.</param>
/// <param name="side">the side to be used.</param>
/// <param name="r">the rectangle that sets the bounds for the track map to be extracted.</param>
/// <param name="flt">the track filter; leave <c>null</c> to skip filtering.</param>
/// <param name="useoriginal">if <c>true</c>, the original (anti-transformed) tracks are used; ignored if the input data is other than a TotalScan volume.</param>
/// <returns>the subset of tracks to be used for mapping.</returns>
public static SySal.Tracking.MIPEmulsionTrackInfo[] ExtractMap(object data, MapSide side, SySal.BasicTypes.Rectangle r, dMapFilter flt, bool useoriginal)
{
if (data is SySal.Scanning.Plate.LinkedZone)
{
return(lzExtractMap((SySal.Scanning.Plate.LinkedZone)data, side, r, flt));
}
else if (data is SySal.TotalScan.Layer)
{
int s = ((SySal.TotalScan.Layer)data).Side;
if (s != (int)side)
{
throw new Exception("Expected side = " + side + " but found " + s + ".");
}
return(layExtractMap((SySal.TotalScan.Layer)data, r, flt, useoriginal));
}
else if (data is SySal.Tracking.MIPEmulsionTrackInfo[])
{
return(tkExtractMap((SySal.Tracking.MIPEmulsionTrackInfo[])data, r, flt));
}
throw new Exception("Map extraction from type " + data.GetType() + " is not supported.");
}
static SySal.Tracking.MIPEmulsionTrackInfo[] tkExtractMap(SySal.Tracking.MIPEmulsionTrackInfo[] tks, SySal.BasicTypes.Rectangle r, dMapFilter flt)
{
System.Collections.ArrayList ar = new System.Collections.ArrayList();
foreach (SySal.Tracking.MIPEmulsionTrackInfo info in tks)
{
if (info.Intercept.X < r.MinX || info.Intercept.X > r.MaxX || info.Intercept.Y < r.MinY || info.Intercept.Y > r.MaxY)
{
continue;
}
if (flt == null || flt(info))
{
ar.Add(info);
}
}
return((SySal.Tracking.MIPEmulsionTrackInfo[])ar.ToArray(typeof(SySal.Tracking.MIPEmulsionTrackInfo)));
}
static SySal.Tracking.MIPEmulsionTrackInfo[] layExtractMap(SySal.TotalScan.Layer lay, SySal.BasicTypes.Rectangle r, dMapFilter flt, bool useoriginal)
{
System.Collections.ArrayList ar = new System.Collections.ArrayList();
int n = lay.Length;
int i;
for (i = 0; i < n; i++)
{
SySal.Tracking.MIPEmulsionTrackInfo info = useoriginal ? lay[i].OriginalInfo : lay[i].Info;
if (info.Intercept.X < r.MinX || info.Intercept.X > r.MaxX || info.Intercept.Y < r.MinY || info.Intercept.Y > r.MaxY)
{
continue;
}
if (flt == null || flt(lay[i]))
{
ar.Add(info);
}
}
return((SySal.Tracking.MIPEmulsionTrackInfo[])ar.ToArray(typeof(SySal.Tracking.MIPEmulsionTrackInfo)));
}
static SySal.Tracking.MIPEmulsionTrackInfo[] lzExtractMap(SySal.Scanning.Plate.LinkedZone lz, MapSide side, SySal.BasicTypes.Rectangle r, dMapFilter flt)
{
System.Collections.ArrayList ar = new System.Collections.ArrayList();
int n;
switch (side)
{
case MapSide.Base: n = lz.Length; break;
case MapSide.Top: n = lz.Top.Length; break;
case MapSide.Bottom: n = lz.Bottom.Length; break;
default: throw new Exception("Internal inconsistency: side = " + side + " is not supported.");
}
int i;
for (i = 0; i < n; i++)
{
SySal.Tracking.MIPEmulsionTrackInfo info;
switch (side)
{
case MapSide.Base: info = lz[i].Info; break;
case MapSide.Top: info = lz.Top[i].Info; break;
case MapSide.Bottom: info = lz.Bottom[i].Info; break;
default: throw new Exception("Internal inconsistency: side = " + side + " is not supported.");
}
if (info.Intercept.X < r.MinX || info.Intercept.X > r.MaxX || info.Intercept.Y < r.MinY || info.Intercept.Y > r.MaxY)
{
continue;
}
if (flt == null || flt(info))
{
ar.Add(info);
}
}
return((SySal.Tracking.MIPEmulsionTrackInfo[])ar.ToArray(typeof(SySal.Tracking.MIPEmulsionTrackInfo)));
}
static void Main(string[] args)
{
if (args.Length != 13 && args.Length != 4 && args.Length != 2)
{
Console.WriteLine("usage: FlattenTLG.exe <cell map> <TLG to be flattened> <output TLG> <min matches>");
Console.WriteLine(" or");
Console.WriteLine("usage: FlattenTLG.exe <cell map> <min matches>");
Console.WriteLine(" (opens a console to query the transformation map generator)");
Console.WriteLine(" or");
Console.WriteLine("usage: FlattenTLG.exe <reference TLG (supposed flat)> <TLG to be flattened> <output TLG> <cell size> <slope tol> <pos tol> <pos sweep> <z projection> <selection string> <min matches> <z adjust> <z step> <parallel (true|false)>");
Console.WriteLine("Selection function variables:");
foreach (SelFunc sf in KnownFunctions)
{
Console.WriteLine(sf.Name + " -> " + sf.Desc);
}
return;
}
bool usereadymap = (args.Length < 13);
bool useconsole = (args.Length == 2);
string reftlg = args[0];
string worktlg = useconsole ? "" : args[1];
string outtlg = useconsole ? "" : args[2];
uint MinMatches = 0;
int xcells = 0;
int ycells = 0;
double cellsize = 0.0;
int ix, iy;
int i, j, k;
SySal.BasicTypes.Vector2 Center = new SySal.BasicTypes.Vector2();
SySal.BasicTypes.Rectangle WorkRect;
SySal.Scanning.Plate.IO.OPERA.LinkedZone worklz = null;
if (useconsole == false)
{
worklz = SySal.DataStreams.OPERALinkedZone.FromFile(worktlg);
WorkRect = worklz.Extents;
}
else
{
WorkRect = new SySal.BasicTypes.Rectangle();
}
SySal.BasicTypes.Rectangle RefRect = new SySal.BasicTypes.Rectangle();
RTrackCell[,] WorkCells;
if (usereadymap)
{
MinMatches = Convert.ToUInt32(args[useconsole ? 1 : 3]);
System.IO.StreamReader cr = new System.IO.StreamReader(args[0]);
while (cr.EndOfStream == false)
{
System.Text.RegularExpressions.Match m = rx_CellMap.Match(cr.ReadLine());
if (m.Success)
{
RefRect.MinX = Convert.ToDouble(m.Groups[1].Value);
RefRect.MaxX = Convert.ToDouble(m.Groups[2].Value);
RefRect.MinY = Convert.ToDouble(m.Groups[3].Value);
RefRect.MaxY = Convert.ToDouble(m.Groups[4].Value);
cellsize = Convert.ToDouble(m.Groups[5].Value);
xcells = Convert.ToInt32(m.Groups[6].Value);
ycells = Convert.ToInt32(m.Groups[7].Value);
break;
}
}
Center.X = 0.5 * (RefRect.MinX + RefRect.MaxX);
Center.Y = 0.5 * (RefRect.MinY + RefRect.MaxY);
WorkCells = new RTrackCell[xcells, ycells];
for (ix = 0; ix < xcells; ix++)
{
for (iy = 0; iy < ycells; iy++)
{
SySal.BasicTypes.Rectangle rect = new SySal.BasicTypes.Rectangle();
rect.MinX = RefRect.MinX + ix * cellsize;
rect.MaxX = rect.MinX + cellsize;
rect.MinY = RefRect.MinY + iy * cellsize;
rect.MaxY = rect.MinY + cellsize;
WorkCells[ix, iy] = new RTrackCell(rect, Center);
WorkCells[ix, iy].Result = NumericalTools.ComputationResult.InvalidInput;
}
}
while (cr.EndOfStream == false)
{
System.Text.RegularExpressions.Match m = rx_Cell.Match(cr.ReadLine());
if (m.Success)
{
ix = Convert.ToInt32(m.Groups[1].Value);
iy = Convert.ToInt32(m.Groups[2].Value);
WorkCells[ix, iy].Result = NumericalTools.ComputationResult.OK;
WorkCells[ix, iy].Matches = Convert.ToInt32(m.Groups[3].Value);
WorkCells[ix, iy].Average.X = Convert.ToDouble(m.Groups[4].Value);
WorkCells[ix, iy].Average.Y = Convert.ToDouble(m.Groups[5].Value);
WorkCells[ix, iy].AlignInfo.MXX = Convert.ToDouble(m.Groups[6].Value);
WorkCells[ix, iy].AlignInfo.MXY = Convert.ToDouble(m.Groups[7].Value);
WorkCells[ix, iy].AlignInfo.MYX = Convert.ToDouble(m.Groups[8].Value);
WorkCells[ix, iy].AlignInfo.MYY = Convert.ToDouble(m.Groups[9].Value);
WorkCells[ix, iy].AlignInfo.TX = Convert.ToDouble(m.Groups[10].Value);
WorkCells[ix, iy].AlignInfo.TY = Convert.ToDouble(m.Groups[11].Value);
WorkCells[ix, iy].AlignInfo.TZ = Convert.ToDouble(m.Groups[12].Value);
WorkCells[ix, iy].SlopeAlignInfo.X = Convert.ToDouble(m.Groups[13].Value);
WorkCells[ix, iy].SlopeAlignInfo.Y = Convert.ToDouble(m.Groups[14].Value);
}
}
cr.Close();
if (useconsole)
{
GridInterpolation G1 = new GridInterpolation(WorkCells, cellsize, RefRect, (int)MinMatches);
Console.WriteLine("Type a pair of coordinates ( X Y ) to get the transformation map.\r\nEOF (CTRL+Z to exit).");
double x, y;
string line;
while ((line = Console.ReadLine()) != null)
{
System.Text.RegularExpressions.Match m = rx_XY.Match(line);
x = Convert.ToDouble(m.Groups[1].Value);
y = Convert.ToDouble(m.Groups[2].Value);
SySal.BasicTypes.Vector dslope = new SySal.BasicTypes.Vector();
SySal.DAQSystem.Scanning.IntercalibrationInfo dpos = new SySal.DAQSystem.Scanning.IntercalibrationInfo();
bool result = G1.Evaluate(x, y, ref dslope, ref dpos);
Console.WriteLine(x + " " + y + " -> " + (result ? "OK" : "FAILED") + " " + dpos.RX + " " + dpos.RY + " " + dpos.MXX + " " + dpos.MXY + " " + dpos.MYX + " " + dpos.MYY + " " + dpos.TX + " " + dpos.TY + " " + dpos.TZ + " " + dslope.X + " " + dslope.Y);
}
return;
}
}
else
{
cellsize = Convert.ToDouble(args[3]);
double slopetol = Convert.ToDouble(args[4]);
double postol = Convert.ToDouble(args[5]);
double possweep = Convert.ToDouble(args[6]);
double DZ = Convert.ToDouble(args[7]);
string selstring = args[8];
MinMatches = Convert.ToUInt32(args[9]);
double ZAdj = Convert.ToDouble(args[10]);
double ZStep = Convert.ToDouble(args[11]);
bool IsParallel = Convert.ToBoolean(args[12]);
NumericalTools.CStyleParsedFunction S = new NumericalTools.CStyleParsedFunction(selstring);
dSel[] pMap = new dSel[S.ParameterList.Length];
for (j = 0; j < S.ParameterList.Length; j++)
{
string sp = S.ParameterList[j];
for (i = 0; i < KnownFunctions.Length && String.Compare(sp, KnownFunctions[i].Name, true) != 0; i++)
{
;
}
if (i == KnownFunctions.Length)
{
throw new Exception("Unknown parameter \"" + sp + "\".");
}
pMap[j] = KnownFunctions[i].Evaluate;
}
SySal.Scanning.Plate.IO.OPERA.LinkedZone reflz = SySal.DataStreams.OPERALinkedZone.FromFile(reftlg);
RefRect = reflz.Extents;
if (WorkRect.MinX > RefRect.MinX)
{
RefRect.MinX = WorkRect.MinX;
}
if (WorkRect.MaxX < RefRect.MaxX)
{
RefRect.MaxX = WorkRect.MaxX;
}
if (WorkRect.MinY > RefRect.MinY)
{
RefRect.MinY = WorkRect.MinY;
}
if (WorkRect.MaxY < RefRect.MaxY)
{
RefRect.MaxY = WorkRect.MaxY;
}
Center.X = 0.5 * (RefRect.MinX + RefRect.MaxX);
Center.Y = 0.5 * (RefRect.MinY + RefRect.MaxY);
xcells = (int)Math.Ceiling((RefRect.MaxX - RefRect.MinX) / cellsize);
ycells = (int)Math.Ceiling((RefRect.MaxY - RefRect.MinY) / cellsize);
Console.WriteLine("X/Y Cells: " + xcells + "/" + ycells);
if (xcells <= 0 || ycells <= 0)
{
throw new Exception("Null working area.");
}
RTrackCell[,] RefCells = new RTrackCell[xcells, ycells];
WorkCells = new RTrackCell[xcells, ycells];
for (ix = 0; ix < xcells; ix++)
{
for (iy = 0; iy < ycells; iy++)
{
SySal.BasicTypes.Rectangle rect = new SySal.BasicTypes.Rectangle();
rect.MinX = RefRect.MinX + ix * cellsize;
rect.MaxX = rect.MinX + cellsize;
rect.MinY = RefRect.MinY + iy * cellsize;
rect.MaxY = rect.MinY + cellsize;
RefCells[ix, iy] = new RTrackCell(rect, Center);
WorkCells[ix, iy] = new RTrackCell(rect, Center);
}
}
SySal.Scanning.Plate.IO.OPERA.LinkedZone lz;
RTrackCell[,] rtc;
for (i = 0; i < 2; i++)
{
if (i == 0)
{
lz = reflz;
rtc = RefCells;
}
else
{
lz = worklz;
rtc = WorkCells;
}
for (j = 0; j < lz.Length; j++)
{
SySal.Scanning.MIPBaseTrack tk = lz[j] as SySal.Scanning.MIPBaseTrack;
for (k = 0; k < pMap.Length; k++)
{
S[k] = pMap[k](tk);
}
if (S.Evaluate() != 0.0)
{
ix = (int)((tk.Info.Intercept.X - RefRect.MinX) / cellsize);
iy = (int)((tk.Info.Intercept.Y - RefRect.MinY) / cellsize);
if (ix >= 0 && ix < xcells && iy >= 0 && iy < ycells)
{
RTrack rtr = new RTrack();
rtr.Slope.X = tk.Info.Slope.X;
rtr.Slope.Y = tk.Info.Slope.Y;
rtr.Position.X = tk.Info.Intercept.X;
rtr.Position.Y = tk.Info.Intercept.Y;
rtc[ix, iy].Add(rtr);
}
}
}
}
for (ix = 0; ix < xcells; ix++)
{
for (iy = 0; iy < ycells; iy++)
{
Console.WriteLine("Ref " + RefCells[ix, iy].Average.X + " " + RefCells[ix, iy].Average.Y + " " + RefCells[ix, iy].Count);
Console.WriteLine("Work " + WorkCells[ix, iy].Average.X + " " + WorkCells[ix, iy].Average.Y + " " + WorkCells[ix, iy].Count);
}
}
SySal.Processing.QuickMapping.QuickMapper QM = new SySal.Processing.QuickMapping.QuickMapper();
SySal.Processing.QuickMapping.Configuration qmc = QM.Config as SySal.Processing.QuickMapping.Configuration;
qmc.FullStatistics = false;
qmc.UseAbsoluteReference = true;
qmc.PosTol = postol;
qmc.SlopeTol = slopetol;
for (ix = 0; ix < xcells; ix++)
{
for (iy = 0; iy < ycells; iy++)
{
SySal.Tracking.MIPEmulsionTrackInfo[] rinfo = new SySal.Tracking.MIPEmulsionTrackInfo[RefCells[ix, iy].Count];
SySal.Tracking.MIPEmulsionTrackInfo[] winfo = new SySal.Tracking.MIPEmulsionTrackInfo[WorkCells[ix, iy].Count];
for (i = 0; i < 2; i++)
{
SySal.Tracking.MIPEmulsionTrackInfo[] inf = (i == 0) ? rinfo : winfo;
RTrackCell[,] cells = (i == 0) ? RefCells : WorkCells;
double dz = (i == 0) ? 0.0 : DZ;
for (j = 0; j < inf.Length; j++)
{
RTrack r = cells[ix, iy].Get(j);
inf[j] = new SySal.Tracking.MIPEmulsionTrackInfo();
inf[j].Slope.X = r.Slope.X;
inf[j].Slope.Y = r.Slope.Y;
inf[j].Intercept.X = r.Position.X;
inf[j].Intercept.Y = r.Position.Y;
inf[j].Intercept.Z = dz;
}
}
SySal.Scanning.PostProcessing.PatternMatching.TrackPair[] pairs = new SySal.Scanning.PostProcessing.PatternMatching.TrackPair[0];
double bestdz = 0.0;
if (rinfo.Length >= 2 && winfo.Length >= 2)
{
double dz1;
if (IsParallel)
{
System.Collections.ArrayList thrarr = new System.Collections.ArrayList();
for (dz1 = -ZAdj; dz1 <= ZAdj; dz1 += ZStep)
{
MapThread mthr = new MapThread();
mthr.m_rinfo = rinfo;
mthr.m_winfo = winfo;
mthr.m_DZ = DZ + dz1;
mthr.m_PosSweep = possweep;
mthr.m_PosTol = postol;
mthr.m_SlopeTol = slopetol;
mthr.m_Thread = new System.Threading.Thread(new System.Threading.ThreadStart(mthr.Execute));
mthr.m_Thread.Start();
thrarr.Add(mthr);
}
foreach (MapThread mt in thrarr)
{
mt.m_Thread.Join();
if (mt.m_Pairs.Length > pairs.Length)
{
bestdz = mt.m_DZ - DZ;
pairs = mt.m_Pairs;
}
}
}
else
{
for (dz1 = -ZAdj; dz1 <= ZAdj; dz1 += ZStep)
{
SySal.Scanning.PostProcessing.PatternMatching.TrackPair[] qairs = QM.Match(rinfo, winfo, DZ + dz1, possweep, possweep);
if (qairs.Length > pairs.Length)
{
bestdz = dz1;
pairs = qairs;
}
}
}
}
double[] alignpars = new double[7];
SySal.BasicTypes.Vector2 slopedelta = new SySal.BasicTypes.Vector2();
SySal.BasicTypes.Vector2 slopetolv = new SySal.BasicTypes.Vector2();
double[] dslx = new double[pairs.Length];
double[] dsly = new double[pairs.Length];
for (j = 0; j < pairs.Length; j++)
{
dslx[j] = pairs[j].First.Info.Slope.X - pairs[j].Second.Info.Slope.X;
}
PeakFit(dslx, slopetol, out slopedelta.X, out slopetolv.X);
for (j = 0; j < pairs.Length; j++)
{
dsly[j] = pairs[j].First.Info.Slope.Y - pairs[j].Second.Info.Slope.Y;
}
PeakFit(dsly, slopetol, out slopedelta.Y, out slopetolv.Y);
int gooddslopes = 0;
for (j = 0; j < pairs.Length; j++)
{
if ((slopedelta.X - slopetolv.X) < dslx[j] && dslx[j] < (slopedelta.X + slopetolv.X) && (slopedelta.Y - slopetolv.Y) < dsly[j] && dsly[j] < (slopedelta.Y + slopetolv.Y))
{
gooddslopes++;
}
}
if (gooddslopes > 0)
{
double[] DX = new double[gooddslopes];
double[] DY = new double[gooddslopes];
double[] X = new double[gooddslopes];
double[] Y = new double[gooddslopes];
double[] SX = new double[gooddslopes];
double[] SY = new double[gooddslopes];
for (j = i = 0; j < pairs.Length; j++)
{
if ((slopedelta.X - slopetolv.X) < dslx[j] && dslx[j] < (slopedelta.X + slopetolv.X) && (slopedelta.Y - slopetolv.Y) < dsly[j] && dsly[j] < (slopedelta.Y + slopetolv.Y))
{
X[i] = pairs[j].Second.Info.Intercept.X - WorkCells[ix, iy].AlignInfo.RX;
Y[i] = pairs[j].Second.Info.Intercept.Y - WorkCells[ix, iy].AlignInfo.RY;
SX[i] = pairs[j].Second.Info.Slope.X;
SY[i] = pairs[j].Second.Info.Slope.Y;
DX[i] = pairs[j].First.Info.Intercept.X - pairs[j].Second.Info.Intercept.X;
DY[i] = pairs[j].First.Info.Intercept.Y - pairs[j].Second.Info.Intercept.Y;
//System.IO.File.AppendAllText(@"c:\flattentlg.txt", "\r\n" + ix + " " + iy + " " + i + " " + j + " " + pairs.Length + " " + gooddslopes + " " + WorkCells[ix, iy].AlignInfo.RX + " " + WorkCells[ix, iy].AlignInfo.RY + " " + X[i] + " " + Y[i] + " " + SX[i] + " " + SY[i] + " " + DX[i] + " " + DY[i] + " " + bestdz);
i++;
}
}
WorkCells[ix, iy].Result = IteratedAffineFocusing(DX, DY, X, Y, SX, SY, postol, ref alignpars);
}
else
{
WorkCells[ix, iy].Result = NumericalTools.ComputationResult.InvalidInput;
}
WorkCells[ix, iy].Matches = pairs.Length;
WorkCells[ix, iy].AlignInfo.TZ = alignpars[6] + bestdz;
WorkCells[ix, iy].AlignInfo.TX = alignpars[4];
WorkCells[ix, iy].AlignInfo.TY = alignpars[5];
WorkCells[ix, iy].AlignInfo.MXX = 1.0 + alignpars[0];
WorkCells[ix, iy].AlignInfo.MXY = 0.0 + alignpars[1];
WorkCells[ix, iy].AlignInfo.MYX = 0.0 + alignpars[2];
WorkCells[ix, iy].AlignInfo.MYY = 1.0 + alignpars[3];
WorkCells[ix, iy].SlopeAlignInfo = slopedelta;
Console.WriteLine("Fit " + WorkCells[ix, iy].Result + " " + WorkCells[ix, iy].AlignInfo.MXX + " " + WorkCells[ix, iy].AlignInfo.MXY + " " + WorkCells[ix, iy].AlignInfo.MYX + " " + WorkCells[ix, iy].AlignInfo.MYY + " " + WorkCells[ix, iy].AlignInfo.TX + " " + WorkCells[ix, iy].AlignInfo.TY + " " + WorkCells[ix, iy].AlignInfo.TZ + " " + WorkCells[ix, iy].SlopeAlignInfo.X + " " + WorkCells[ix, iy].SlopeAlignInfo.Y);
}
}
int goodcells = 0;
for (ix = 0; ix < xcells; ix++)
{
for (iy = 0; iy < ycells; iy++)
{
if (WorkCells[ix, iy].Result == NumericalTools.ComputationResult.OK && WorkCells[ix, iy].Matches >= MinMatches)
{
goodcells++;
}
}
}
Console.WriteLine("Good cells: " + goodcells);
Console.WriteLine("--------CELLS");
Console.WriteLine("CELLMAP " + RefRect.MinX + " " + RefRect.MaxX + " " + RefRect.MinY + " " + RefRect.MaxY + " " + cellsize + " " + xcells + " " + ycells);
Console.WriteLine("IX\tIY\tN\tX\tY\tMXX\tMXY\tMYX\tMYY\tTX\tTY\tTZ\tTDSX\tTDSY");
for (ix = 0; ix < xcells; ix++)
{
for (iy = 0; iy < ycells; iy++)
{
if (WorkCells[ix, iy].Result == NumericalTools.ComputationResult.OK && WorkCells[ix, iy].Matches >= MinMatches)
{
Console.WriteLine(ix + "\t" + iy + "\t" + WorkCells[ix, iy].Matches + "\t" + WorkCells[ix, iy].Average.X + "\t" + WorkCells[ix, iy].Average.Y + "\t" + WorkCells[ix, iy].AlignInfo.MXX + "\t" + WorkCells[ix, iy].AlignInfo.MXY + "\t" + WorkCells[ix, iy].AlignInfo.MYX + "\t" + WorkCells[ix, iy].AlignInfo.MYY + "\t" + WorkCells[ix, iy].AlignInfo.TX + "\t" + WorkCells[ix, iy].AlignInfo.TY + "\t" + WorkCells[ix, iy].AlignInfo.TZ + "\t" + WorkCells[ix, iy].SlopeAlignInfo.X + "\t" + WorkCells[ix, iy].SlopeAlignInfo.Y);
}
}
}
Console.WriteLine("--------ENDCELLS");
}
SySal.DataStreams.OPERALinkedZone.Writer outlzw = new SySal.DataStreams.OPERALinkedZone.Writer(outtlg, worklz.Id, worklz.Extents, worklz.Center, worklz.Transform);
outlzw.SetZInfo(worklz.Top.TopZ, worklz.Top.BottomZ, worklz.Bottom.TopZ, worklz.Bottom.BottomZ);
for (i = 0; i < ((SySal.Scanning.Plate.IO.OPERA.LinkedZone.Side)worklz.Top).ViewCount; i++)
{
outlzw.AddView(((SySal.Scanning.Plate.IO.OPERA.LinkedZone.Side)worklz.Top).View(i), true);
}
for (i = 0; i < ((SySal.Scanning.Plate.IO.OPERA.LinkedZone.Side)worklz.Bottom).ViewCount; i++)
{
outlzw.AddView(((SySal.Scanning.Plate.IO.OPERA.LinkedZone.Side)worklz.Bottom).View(i), false);
}
SySal.BasicTypes.Vector proj = new SySal.BasicTypes.Vector();
Console.WriteLine("Writing flattened TLG...");
GridInterpolation G = new GridInterpolation(WorkCells, cellsize, RefRect, (int)MinMatches);
System.DateTime start = System.DateTime.Now;
for (i = 0; i < worklz.Length; i++)
{
if (i % 1000 == 0)
{
System.DateTime nw = System.DateTime.Now;
if ((nw - start).TotalMilliseconds >= 10000)
{
Console.WriteLine((i * 100 / worklz.Length) + "%");
start = nw;
}
}
SySal.Tracking.MIPEmulsionTrackInfo baseinfo = worklz[i].Info;
SySal.DAQSystem.Scanning.IntercalibrationInfo transforminfo = new SySal.DAQSystem.Scanning.IntercalibrationInfo();
transforminfo.RX = Center.X;
transforminfo.RY = Center.Y;
SySal.BasicTypes.Vector tds = new SySal.BasicTypes.Vector();
G.Evaluate(baseinfo.Intercept.X, baseinfo.Intercept.Y, ref tds, ref transforminfo);
proj.X = -baseinfo.Slope.X * transforminfo.TZ;
proj.Y = -baseinfo.Slope.Y * transforminfo.TZ;
proj.Z = 0.0;
baseinfo.Intercept = transforminfo.Transform(baseinfo.Intercept) + proj;
baseinfo.Slope = transforminfo.Deform(baseinfo.Slope) + tds;
SySal.Scanning.MIPIndexedEmulsionTrack toptk = worklz[i].Top;
SySal.Tracking.MIPEmulsionTrackInfo topinfo = toptk.Info;
SySal.Scanning.MIPIndexedEmulsionTrack bottomtk = worklz[i].Bottom;
SySal.Tracking.MIPEmulsionTrackInfo bottominfo = bottomtk.Info;
topinfo.Intercept = transforminfo.Transform(topinfo.Intercept) + proj;
topinfo.Slope = transforminfo.Deform(topinfo.Slope) + tds;
bottominfo.Intercept = transforminfo.Transform(bottominfo.Intercept) + proj;
bottominfo.Slope = transforminfo.Deform(bottominfo.Slope) + tds;
outlzw.AddMIPEmulsionTrack(topinfo, i, ((SySal.Scanning.Plate.IO.OPERA.LinkedZone.MIPIndexedEmulsionTrack)toptk).View.Id, ((SySal.Scanning.Plate.IO.OPERA.LinkedZone.MIPIndexedEmulsionTrack)toptk).OriginalRawData, true);
outlzw.AddMIPEmulsionTrack(bottominfo, i, ((SySal.Scanning.Plate.IO.OPERA.LinkedZone.MIPIndexedEmulsionTrack)bottomtk).View.Id, ((SySal.Scanning.Plate.IO.OPERA.LinkedZone.MIPIndexedEmulsionTrack)bottomtk).OriginalRawData, false);
outlzw.AddMIPBasetrack(baseinfo, i, i, i);
}
outlzw.Complete();
Console.WriteLine("Written \"" + outtlg + "\".");
}