private Point GetPointXY(Edge edge, double value, ValuesInCell vc, IrregularCell rect)
{
double lt = vc.LeftTop;
double lb = vc.LeftBottom;
double rb = vc.RightBottom;
double rt = vc.RightTop;
switch (edge)
{
case Edge.Left:
return(GetPoint(value, lb, lt, rect.LeftBottom, rect.LeftTop));
case Edge.Top:
return(GetPoint(value, lt, rt, rect.LeftTop, rect.RightTop));
case Edge.Right:
return(GetPoint(value, rb, rt, rect.RightBottom, rect.RightTop));
case Edge.Bottom:
return(GetPoint(value, lb, rb, rect.LeftBottom, rect.RightBottom));
default:
throw new InvalidOperationException();
}
}
private void TrackLineNonRecursive(Edge inEdge, double value, int x, int y)
{
int s = x, t = y;
ValuesInCell vc = new ValuesInCell(
values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1]);
IrregularCell rect = new IrregularCell(
grid[x, y],
grid[x + 1, y],
grid[x + 1, y + 1],
grid[x, y + 1]);
Point point = GetPointXY(inEdge, value, vc, rect);
segments.StartLine(point, currentRatio, value);
MakeEdgePassed(inEdge, x, y);
double x2, y2;
do
{
inEdge = TrackLine(inEdge, value, ref s, ref t, out x2, out y2);
} while (s != -1);
}
private Edge GetOutForOpposite(Edge inEdge, CellBitmask cellVal, double value, ValuesInCell cellValues, IrregularCell rect)
{
Edge outEdge;
SubCell subCell = GetSubCell(inEdge, value, cellValues);
int iters = 1000; // max number of iterations
do
{
ValuesInCell subValues = cellValues.GetSubCell(subCell);
IrregularCell subRect = rect.GetSubRect(subCell);
outEdge = GetOutEdge(inEdge, subValues, subRect, value);
bool isAppropriate = subCell.IsAppropriate(outEdge);
if (isAppropriate)
{
ValuesInCell sValues = subValues.GetSubCell(subCell);
Point point = GetPointXY(outEdge, value, subValues, subRect);
segments.AddPoint(point);
return(outEdge);
}
else
{
subCell = GetAdjacentEdge(subCell, outEdge);
}
byte e = (byte)outEdge;
inEdge = (Edge)((e > 2) ? (e >> 2) : (e << 2));
iters--;
} while (iters >= 0);
throw new IsolineGenerationException(Strings.Exceptions.IsolinesDataIsUndetailized);
}
private Edge TrackLine(Edge inEdge, double value, ref int x, ref int y, out double newX, out double newY)
{
// Getting output edge
ValuesInCell vc = new ValuesInCell(
values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1]);
IrregularCell rect = new IrregularCell(
grid[x, y],
grid[x + 1, y],
grid[x + 1, y + 1],
grid[x, y + 1]);
Edge outEdge = GetOutEdge(inEdge, vc, rect, value);
// Drawing new segment
Point point = GetPointXY(outEdge, value, vc, rect);
newX = point.X;
newY = point.Y;
segments.AddPoint(point);
// Whether out-edge already was passed?
if (IsPassed(outEdge, x, y, edges)) // line is closed
{
MakeEdgePassed(outEdge, x, y); // boundaries should be marked as passed too
x = y = -1;
return(Edge.Bottom);
}
// Make this edge passed
MakeEdgePassed(outEdge, x, y);
// Getting next cell's indices
switch (outEdge)
{
case Edge.Left:
x--;
return(Edge.Right);
case Edge.Top:
y++;
return(Edge.Bottom);
case Edge.Right:
x++;
return(Edge.Left);
case Edge.Bottom:
y--;
return(Edge.Top);
default:
throw new InvalidOperationException();
}
}
private void TrackLineNonRecursive(Edge inEdge, double value, int x, int y)
{
int s = x, t = y;
ValuesInCell vc = (missingValue.IsNaN()) ?
(new ValuesInCell(values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1])) :
(new ValuesInCell(values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1],
missingValue));
IrregularCell rect = new IrregularCell(
grid[x, y],
grid[x + 1, y],
grid[x + 1, y + 1],
grid[x, y + 1]);
Point point = GetPointXY(inEdge, value, vc, rect);
segments.StartLine(point, (value - minMax.Min) / (minMax.Max - minMax.Min), value);
MakeEdgePassed(inEdge, x, y);
//processed[x, y] = true;
double x2, y2;
do
{
inEdge = TrackLine(inEdge, value, ref s, ref t, out x2, out y2);
} while (inEdge != Edge.None);
}
private void TrackLineNonRecursive(Edge inEdge, double value, int x, int y)
{
int s = x, t = y;
ValuesInCell vc = (missingValue.IsNaN()) ?
(new ValuesInCell(values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1])) :
(new ValuesInCell(values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1],
missingValue));
IrregularCell rect = new IrregularCell(
grid[x, y],
grid[x + 1, y],
grid[x + 1, y + 1],
grid[x, y + 1]);
Point point = GetPointXY(inEdge, value, vc, rect);
segments.StartLine(point, (value - minMax.Min) / (minMax.Max - minMax.Min), value);
MakeEdgePassed(inEdge, x, y);
//processed[x, y] = true;
double x2, y2;
do
{
inEdge = TrackLine(inEdge, value, ref s, ref t, out x2, out y2);
} while (inEdge != Edge.None);
}
private Edge TrackLine(Edge inEdge, double value, ref int x, ref int y, out double newX, out double newY)
{
// Getting output edge
ValuesInCell vc = (missingValue.IsNaN()) ?
(new ValuesInCell(values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1])) :
(new ValuesInCell(values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1],
missingValue));
IrregularCell rect = new IrregularCell(
grid[x, y],
grid[x + 1, y],
grid[x + 1, y + 1],
grid[x, y + 1]);
Edge outEdge = GetOutEdge(inEdge, vc, rect, value);
if (outEdge == Edge.None)
{
newX = newY = -1; // Impossible cell indices
return Edge.None;
}
// Drawing new segment
Point point = GetPointXY(outEdge, value, vc, rect);
newX = point.X;
newY = point.Y;
segments.AddPoint(point);
processed[x, y] = true;
// Whether out-edge already was passed?
if (IsPassed(outEdge, x, y, edges)) // line is closed
{
//MakeEdgePassed(outEdge, x, y); // boundaries should be marked as passed too
return Edge.None;
}
// Make this edge passed
MakeEdgePassed(outEdge, x, y);
// Getting next cell's indices
switch (outEdge)
{
case Edge.Left:
x--;
return Edge.Right;
case Edge.Top:
y++;
return Edge.Bottom;
case Edge.Right:
x++;
return Edge.Left;
case Edge.Bottom:
y--;
return Edge.Top;
default:
throw new InvalidOperationException();
}
}
private Point GetPointXY(Edge edge, double value, ValuesInCell vc, IrregularCell rect)
{
double lt = vc.LeftTop;
double lb = vc.LeftBottom;
double rb = vc.RightBottom;
double rt = vc.RightTop;
switch (edge)
{
case Edge.Left:
return GetPoint(value, lb, lt, rect.LeftBottom, rect.LeftTop);
case Edge.Top:
return GetPoint(value, lt, rt, rect.LeftTop, rect.RightTop);
case Edge.Right:
return GetPoint(value, rb, rt, rect.RightBottom, rect.RightTop);
case Edge.Bottom:
return GetPoint(value, lb, rb, rect.LeftBottom, rect.RightBottom);
default:
throw new InvalidOperationException();
}
}
private Edge GetOutForOpposite(Edge inEdge, CellBitmask cellVal, double value, ValuesInCell cellValues, IrregularCell rect)
{
Edge outEdge;
SubCell subCell = GetSubCell(inEdge, value, cellValues);
int iters = 1000; // max number of iterations
do
{
ValuesInCell subValues = cellValues.GetSubCell(subCell);
IrregularCell subRect = rect.GetSubRect(subCell);
outEdge = GetOutEdge(inEdge, subValues, subRect, value);
if (outEdge == Edge.None)
return Edge.None;
bool isAppropriate = subCell.IsAppropriate(outEdge);
if (isAppropriate)
{
ValuesInCell sValues = subValues.GetSubCell(subCell);
Point point = GetPointXY(outEdge, value, subValues, subRect);
segments.AddPoint(point);
return outEdge;
}
else
{
subCell = GetAdjacentEdge(subCell, outEdge);
}
byte e = (byte)outEdge;
inEdge = (Edge)((e > 2) ? (e >> 2) : (e << 2));
iters--;
} while (iters >= 0);
throw new IsolineGenerationException(Strings.Exceptions.IsolinesDataIsUndetailized);
}
private Edge GetOutEdge(Edge inEdge, ValuesInCell cv, IrregularCell rect, double value)
{
// value smaller than all values in corners or
// value greater than all values in corners
if (!cv.ValueBelongTo(value))
{
throw new IsolineGenerationException(Strings.Exceptions.IsolinesValueIsOutOfCell);
}
CellBitmask cellVal = cv.GetCellValue(value);
var dict = dictChooser[(int)inEdge];
if (dict.ContainsKey((int)cellVal))
{
Edge result = dict[(int)cellVal];
switch (result)
{
case Edge.Left:
if (cv.LeftTop.IsNaN() || cv.LeftBottom.IsNaN())
result = Edge.None;
break;
case Edge.Right:
if (cv.RightTop.IsNaN() || cv.RightBottom.IsNaN())
result = Edge.None;
break;
case Edge.Top:
if (cv.RightTop.IsNaN() || cv.LeftTop.IsNaN())
result = Edge.None;
break;
case Edge.Bottom:
if (cv.LeftBottom.IsNaN() || cv.RightBottom.IsNaN())
result = Edge.None;
break;
}
return result;
}
else if (cellVal.IsDiagonal())
{
return GetOutForOpposite(inEdge, cellVal, value, cv, rect);
}
const double near_zero = 0.0001;
const double near_one = 1 - near_zero;
double lt = cv.LeftTop;
double rt = cv.RightTop;
double rb = cv.RightBottom;
double lb = cv.LeftBottom;
switch (inEdge)
{
case Edge.Left:
if (value == lt)
value = near_one * lt + near_zero * lb;
else if (value == lb)
value = near_one * lb + near_zero * lt;
else
return Edge.None;
// Now this is possible because of missing value
//throw new IsolineGenerationException(Strings.Exceptions.IsolinesUnsupportedCase);
break;
case Edge.Top:
if (value == rt)
value = near_one * rt + near_zero * lt;
else if (value == lt)
value = near_one * lt + near_zero * rt;
else
return Edge.None;
// Now this is possibe because of missing value
//throw new IsolineGenerationException(Strings.Exceptions.IsolinesUnsupportedCase);
break;
case Edge.Right:
if (value == rb)
value = near_one * rb + near_zero * rt;
else if (value == rt)
value = near_one * rt + near_zero * rb;
else
return Edge.None;
// Now this is possibe because of missing value
//throw new IsolineGenerationException(Strings.Exceptions.IsolinesUnsupportedCase);
break;
case Edge.Bottom:
if (value == rb)
value = near_one * rb + near_zero * lb;
else if (value == lb)
value = near_one * lb + near_zero * rb;
else
return Edge.None;
// Now this is possibe because of missing value
//throw new IsolineGenerationException(Strings.Exceptions.IsolinesUnsupportedCase);
break;
}
// Recursion?
//return GetOutEdge(inEdge, cv, rect, value);
return Edge.None;
}
private Edge GetOutEdge(Edge inEdge, ValuesInCell cv, IrregularCell rect, double value)
{
// value smaller than all values in corners or
// value greater than all values in corners
if (!cv.ValueBelongTo(value))
{
throw new IsolineGenerationException(Strings.Exceptions.IsolinesValueIsOutOfCell);
}
CellBitmask cellVal = cv.GetCellValue(value);
var dict = dictChooser[(int)inEdge];
if (dict.ContainsKey((int)cellVal))
{
Edge result = dict[(int)cellVal];
switch (result)
{
case Edge.Left:
if (cv.LeftTop.IsNaN() || cv.LeftBottom.IsNaN())
{
result = Edge.None;
}
break;
case Edge.Right:
if (cv.RightTop.IsNaN() || cv.RightBottom.IsNaN())
{
result = Edge.None;
}
break;
case Edge.Top:
if (cv.RightTop.IsNaN() || cv.LeftTop.IsNaN())
{
result = Edge.None;
}
break;
case Edge.Bottom:
if (cv.LeftBottom.IsNaN() || cv.RightBottom.IsNaN())
{
result = Edge.None;
}
break;
}
return(result);
}
else if (cellVal.IsDiagonal())
{
return(GetOutForOpposite(inEdge, cellVal, value, cv, rect));
}
const double near_zero = 0.0001;
const double near_one = 1 - near_zero;
double lt = cv.LeftTop;
double rt = cv.RightTop;
double rb = cv.RightBottom;
double lb = cv.LeftBottom;
switch (inEdge)
{
case Edge.Left:
if (value == lt)
{
value = near_one * lt + near_zero * lb;
}
else if (value == lb)
{
value = near_one * lb + near_zero * lt;
}
else
{
return(Edge.None);
}
// Now this is possible because of missing value
//throw new IsolineGenerationException(Strings.Exceptions.IsolinesUnsupportedCase);
break;
case Edge.Top:
if (value == rt)
{
value = near_one * rt + near_zero * lt;
}
else if (value == lt)
{
value = near_one * lt + near_zero * rt;
}
else
{
return(Edge.None);
}
// Now this is possibe because of missing value
//throw new IsolineGenerationException(Strings.Exceptions.IsolinesUnsupportedCase);
break;
case Edge.Right:
if (value == rb)
{
value = near_one * rb + near_zero * rt;
}
else if (value == rt)
{
value = near_one * rt + near_zero * rb;
}
else
{
return(Edge.None);
}
// Now this is possibe because of missing value
//throw new IsolineGenerationException(Strings.Exceptions.IsolinesUnsupportedCase);
break;
case Edge.Bottom:
if (value == rb)
{
value = near_one * rb + near_zero * lb;
}
else if (value == lb)
{
value = near_one * lb + near_zero * rb;
}
else
{
return(Edge.None);
}
// Now this is possibe because of missing value
//throw new IsolineGenerationException(Strings.Exceptions.IsolinesUnsupportedCase);
break;
}
// Recursion?
//return GetOutEdge(inEdge, cv, rect, value);
return(Edge.None);
}
private void TrackLineNonRecursive(Edge inEdge, double value, int x, int y)
{
int s = x, t = y;
ValuesInCell vc = new ValuesInCell(
values[x, y],
values[x + 1, y],
values[x + 1, y + 1],
values[x, y + 1]);
IrregularCell rect = new IrregularCell(
grid[x, y],
grid[x + 1, y],
grid[x + 1, y + 1],
grid[x, y + 1]);
Point point = GetPointXY(inEdge, value, vc, rect);
segments.StartLine(point, currentRatio, value);
MakeEdgePassed(inEdge, x, y);
double x2, y2;
do
{
inEdge = TrackLine(inEdge, value, ref s, ref t, out x2, out y2);
} while (s != -1);
}
private Edge GetOutEdge(Edge inEdge, ValuesInCell cv, IrregularCell rect, double value)
{
// value smaller than all values in corners or
// value greater than all values in corners
if (!cv.ValueBelongTo(value))
{
throw new IsolineGenerationException(Properties.Resources.IsolinesValueIsOutOfCell);
}
CellBitmask cellVal = cv.GetCellValue(value);
var dict = dictChooser[(int)inEdge];
if (dict.ContainsKey((int)cellVal))
{
return dict[(int)cellVal];
}
else if (cellVal.IsDiagonal())
{
return GetOutForOpposite(inEdge, cellVal, value, cv, rect);
}
const double near_zero = 0.0001;
const double near_one = 1 - near_zero;
double lt = cv.LeftTop;
double rt = cv.RightTop;
double rb = cv.RightBottom;
double lb = cv.LeftBottom;
switch (inEdge)
{
case Edge.Left:
if (value == lt)
value = near_one * lt + near_zero * rt;
else if (value == rt)
value = near_one * rt + near_zero * lt;
else
throw new IsolineGenerationException(Properties.Resources.IsolinesUnsupportedCase);
break;
case Edge.Top:
if (value == rt)
value = near_one * rt + near_zero * lt;
else if (value == lt)
value = near_one * lt + near_zero * rt;
else
throw new IsolineGenerationException(Properties.Resources.IsolinesUnsupportedCase);
break;
case Edge.Right:
if (value == rb)
value = near_one * rb + near_zero * rt;
else if (value == rt)
value = near_one * rt + near_zero * rb;
else
throw new IsolineGenerationException(Properties.Resources.IsolinesUnsupportedCase);
break;
case Edge.Bottom:
if (value == rb)
value = near_one * rb + near_zero * lb;
else if (value == lb)
value = near_one * lb + near_zero * rb;
else
throw new IsolineGenerationException(Properties.Resources.IsolinesUnsupportedCase);
break;
}
return GetOutEdge(inEdge, cv, rect, value);
}
private Edge GetOutEdge(Edge inEdge, ValuesInCell cv, IrregularCell rect, double value)
{
// value smaller than all values in corners or
// value greater than all values in corners
if (!cv.ValueBelongTo(value))
{
throw new IsolineGenerationException(Properties.Resources.IsolinesValueIsOutOfCell);
}
CellBitmask cellVal = cv.GetCellValue(value);
var dict = dictChooser[(int)inEdge];
if (dict.ContainsKey((int)cellVal))
{
return(dict[(int)cellVal]);
}
else if (cellVal.IsDiagonal())
{
return(GetOutForOpposite(inEdge, cellVal, value, cv, rect));
}
const double near_zero = 0.0001;
const double near_one = 1 - near_zero;
double lt = cv.LeftTop;
double rt = cv.RightTop;
double rb = cv.RightBottom;
double lb = cv.LeftBottom;
switch (inEdge)
{
case Edge.Left:
if (value == lt)
{
value = near_one * lt + near_zero * rt;
}
else if (value == rt)
{
value = near_one * rt + near_zero * lt;
}
else
{
throw new IsolineGenerationException(Properties.Resources.IsolinesUnsupportedCase);
}
break;
case Edge.Top:
if (value == rt)
{
value = near_one * rt + near_zero * lt;
}
else if (value == lt)
{
value = near_one * lt + near_zero * rt;
}
else
{
throw new IsolineGenerationException(Properties.Resources.IsolinesUnsupportedCase);
}
break;
case Edge.Right:
if (value == rb)
{
value = near_one * rb + near_zero * rt;
}
else if (value == rt)
{
value = near_one * rt + near_zero * rb;
}
else
{
throw new IsolineGenerationException(Properties.Resources.IsolinesUnsupportedCase);
}
break;
case Edge.Bottom:
if (value == rb)
{
value = near_one * rb + near_zero * lb;
}
else if (value == lb)
{
value = near_one * lb + near_zero * rb;
}
else
{
throw new IsolineGenerationException(Properties.Resources.IsolinesUnsupportedCase);
}
break;
}
return(GetOutEdge(inEdge, cv, rect, value));
}
