public void PointOnSegSide2()
{
var random = new Random(666);
for (var i = 0; i < 1000; i++)
{
var startY = +1 + 666 * random.NextDouble();
var endY = -1 - 666 * random.NextDouble();
var pointY = 666 * random.NextDouble() - 333;
var frontSideX = -1 - 666 * random.NextDouble();
var backSideX = -frontSideX;
var vertex1 = new Vertex(Fixed.Zero, Fixed.FromDouble(startY));
var vertex2 = new Vertex(Fixed.Zero, Fixed.FromDouble(endY - startY));
var seg = new Seg(
vertex1,
vertex2,
Fixed.Zero, Angle.Ang0, null, null, null, null);
var y = Fixed.FromDouble(pointY);
{
var x = Fixed.FromDouble(frontSideX);
Assert.AreEqual(0, Geometry.PointOnSegSide(x, y, seg));
}
{
var x = Fixed.FromDouble(backSideX);
Assert.AreEqual(1, Geometry.PointOnSegSide(x, y, seg));
}
}
}
public object ConvertBack(object value, Type targetType,
object parameter, CultureInfo culture)
{
Seg seg = null;
return(seg);
}
public void LoadMap01()
{
using (var wad = new Wad(WadPath.Doom2))
{
var flats = new FlatLookup(wad, true);
var textures = new TextureLookup(wad, true);
var map = wad.GetLumpNumber("MAP01");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
var subsectors = Subsector.FromWad(wad, map + 6, segs);
Assert.AreEqual(194, subsectors.Length);
Assert.AreEqual(4, subsectors[0].SegCount);
for (var i = 0; i < 4; i++)
{
Assert.IsTrue(segs[subsectors[0].FirstSeg + i] == segs[i]);
}
Assert.AreEqual(4, subsectors[57].SegCount);
for (var i = 0; i < 4; i++)
{
Assert.IsTrue(segs[subsectors[57].FirstSeg + i] == segs[179 + i]);
}
Assert.AreEqual(4, subsectors[193].SegCount);
for (var i = 0; i < 4; i++)
{
Assert.IsTrue(segs[subsectors[193].FirstSeg + i] == segs[597 + i]);
}
}
}
public void LoadE1M1()
{
using (var wad = new Wad(WadPath.Doom1))
{
var flats = new FlatLookup(wad, true);
var textures = new TextureLookup(wad, true);
var map = wad.GetLumpNumber("E1M1");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
var subsectors = Subsector.FromWad(wad, map + 6, segs);
Assert.AreEqual(239, subsectors.Length);
Assert.AreEqual(8, subsectors[0].SegCount);
for (var i = 0; i < 8; i++)
{
Assert.IsTrue(segs[subsectors[0].FirstSeg + i] == segs[0 + i]);
}
Assert.AreEqual(1, subsectors[54].SegCount);
for (var i = 0; i < 1; i++)
{
Assert.IsTrue(segs[subsectors[54].FirstSeg + i] == segs[181 + i]);
}
Assert.AreEqual(2, subsectors[238].SegCount);
for (var i = 0; i < 2; i++)
{
Assert.IsTrue(segs[subsectors[238].FirstSeg + i] == segs[745 + i]);
}
}
}
public void GetNextFace()
{
Seg = Next.edge.segments[edgeDirs[Dir][Next.dir]];
Dir = cubeDirs[Next.dir];
Next = Seg.GetOppositeEdge(Next.edge);
EndFound = false;
}
public int TryGetStart(ref Side left, ref Side right)
{
Side center = this;
DirEdge opp = Seg.GetOppositeEdge(Next.edge);
if (center.CanGetEnd())
{
left = center;
right.Seg = opp.edge.segments[edgeDirs[Dir][opp.dir]];
right.Next = right.Seg.GetOppositeEdge(opp.edge);
right.Dir = cubeDirs[opp.dir];
right.EndFound = false;
return(right.CanGetEnd() ? 2 : 1);
}
center.Next = opp;
if (center.CanGetEnd())
{
left.Seg = Next.edge.segments[edgeDirs[Dir][Next.dir]];
left.Next = left.Seg.GetOppositeEdge(Next.edge);
left.Dir = cubeDirs[Next.dir];
left.EndFound = false;
right = center;
return(left.CanGetEnd() ? 2 : 1);
}
return(0);
}
//this should really check everything about the board - regen hits and replay everything.
public static void DoDebug(Level l, bool show = false, bool validateBoard = false)
{
if (validateBoard)
{
if (show)
{
ShowSeg(l);
ShowHit(l);
Show(l);
}
//always validate segs.
uint lastIndex = 0;
foreach (var seg in l.Segs)
{
if (seg.Len == 0)
{
WL("Bada");
}
if (show)
{
WL(seg.ToString());
}
if (lastIndex == 0)
{
lastIndex = seg.Index;
continue;
}
if (seg.Index < lastIndex)
{
//in preparation for well-spaced indexes, this should be > last rather than ==last+1
WL("Badb");
}
lastIndex = seg.Index;
}
Seg lastSeg = null;
foreach (var seg in l.Segs)
{
if (lastSeg != null)
{
if ((HDirs.Contains(lastSeg.Dir) && !VDirs.Contains(seg.Dir)) ||
(VDirs.Contains(lastSeg.Dir) && !HDirs.Contains(seg.Dir)))
{
WL("Badc");
}
}
lastSeg = seg;
}
//recalculate the entire board and segs.
var fakeRows = new Dictionary <(int, int), Seg>();
var fakeHits = new Dictionary <(int, int), List <Seg> >();
for (var yy = 0; yy < l.Height; yy++)
{
for (var xx = 0; xx < l.Width; xx++)
{
fakeHits[(xx, yy)] = new List <Seg>();
public bool TryGetNextFace()
{
Seg = Next.edge.segments[edgeDirs[Dir][Next.dir]];
Dir = cubeDirs[Next.dir];
Next = Seg.TryGetOppositeEdge(Dir, Next.edge);
return(Next != DirEdge.zero);
}
void Start()
{
map = WADReader.LoadMap("E1M1");
vertices = new List <Vector3>();
List <CombineInstance> floorCIs = new List <CombineInstance>();
foreach (SubSector ssector in map.subsectors)
{
List <Vector3> floorVerts = new List <Vector3>();
//SubSector ssector = map.subsectors[0];
for (int i = 0; i < ssector.num; i++)
{
Seg seg = map.segs[ssector.start + i];
Vertex vertS = map.vertexes[seg.start];
Vertex vertE = map.vertexes[seg.end];
Linedef line = map.linedefs[seg.linedef];
Sidedef sideR = map.sidedefs[line.right];
Sector sectorR = map.sectors[sideR.sector];
if (line.left >= 0)
{
Sidedef sideL = map.sidedefs[line.left];
Sector sectorL = map.sectors[sideL.sector];
}
Vector3 vStart = new Vector3(vertS.x, 0, vertS.y) * scale;
Vector3 vEnd = new Vector3(vertE.x, 0, vertE.y) * scale;
/*if (!floorVerts.Contains(vStart))*/ floorVerts.Add(vStart);
/*if (!floorVerts.Contains(vEnd))*/ floorVerts.Add(vEnd);
}
List <int> floorTris = new List <int>();
int p0 = 0;
int pHelper = 1;
for (int i = 2; i < floorVerts.Count; i++)
{
int pTemp = i;
floorTris.AddRange(new int[] { p0, pHelper, pTemp });
pHelper = pTemp;
}
CombineInstance ci = new CombineInstance();
Mesh mesh = new Mesh();
mesh.vertices = floorVerts.ToArray();
mesh.triangles = floorTris.ToArray();
mesh.RecalculateNormals();
ci.mesh = mesh;
ci.transform = transform.localToWorldMatrix;
floorCIs.Add(ci);
}
Mesh combinedFloor = new Mesh();
combinedFloor.CombineMeshes(floorCIs.ToArray());
meshFilter.sharedMesh = combinedFloor;
inited = true;
}
public void OnWormSegHit(Seg victim, GameObject hitter)
{
if (state == "level")
{
state = "dead";
deathScreen.SetActive(true);
AudioSource.PlayClipAtPoint(die, transform.position);
}
}
/// <summary>
/// Lay down a label.
/// </summary>
/// <param name="seg"></param>
/// <param name="label"></param>
/// <param name="isGlobal"></param>
public void Tag(Seg seg, string label, bool isGlobal = false)
{
StringBuilder sb = seg == Seg.DATA ? data : text;
if (isGlobal)
{
sb.Append(string.Format("\t.globl {0}\n", label));
}
sb.Append(string.Format("{0}:\n", label));
}
public void LoadE1M1()
{
using (var wad = new Wad(WadPath.Doom1))
{
var flats = new DummyFlatLookup(wad);
var textures = new DummyTextureLookup(wad);
var map = wad.GetLumpNumber("E1M1");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
Assert.AreEqual(747, segs.Length);
Assert.IsTrue(segs[0].Vertex1 == vertices[132]);
Assert.IsTrue(segs[0].Vertex2 == vertices[133]);
Assert.AreEqual(ToRadian(4156), segs[0].Angle.ToRadian(), delta);
Assert.IsTrue(segs[0].LineDef == lines[160]);
Assert.IsTrue((segs[0].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[0].FrontSector == segs[0].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[0].BackSector == segs[0].LineDef.BackSide.Sector);
Assert.AreEqual(0, segs[0].Offset.ToDouble(), delta);
Assert.IsTrue(segs[28].Vertex1 == vertices[390]);
Assert.IsTrue(segs[28].Vertex2 == vertices[131]);
Assert.AreEqual(ToRadian(-32768), segs[28].Angle.ToRadian(), delta);
Assert.IsTrue(segs[28].LineDef == lines[480]);
Assert.IsTrue((segs[0].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[28].FrontSector == segs[28].LineDef.BackSide.Sector);
Assert.IsTrue(segs[28].BackSector == segs[28].LineDef.FrontSide.Sector);
Assert.AreEqual(0, segs[28].Offset.ToDouble(), delta);
Assert.IsTrue(segs[744].Vertex1 == vertices[446]);
Assert.IsTrue(segs[744].Vertex2 == vertices[374]);
Assert.AreEqual(ToRadian(-16384), segs[744].Angle.ToRadian(), delta);
Assert.IsTrue(segs[744].LineDef == lines[452]);
Assert.IsTrue((segs[744].LineDef.Flags & LineFlags.TwoSided) == 0);
Assert.IsTrue(segs[744].FrontSector == segs[744].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[744].BackSector == null);
Assert.AreEqual(154, segs[744].Offset.ToDouble(), delta);
Assert.IsTrue(segs[746].Vertex1 == vertices[374]);
Assert.IsTrue(segs[746].Vertex2 == vertices[368]);
Assert.AreEqual(ToRadian(-13828), segs[746].Angle.ToRadian(), delta);
Assert.IsTrue(segs[746].LineDef == lines[451]);
Assert.IsTrue((segs[746].LineDef.Flags & LineFlags.TwoSided) == 0);
Assert.IsTrue(segs[746].FrontSector == segs[746].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[746].BackSector == null);
Assert.AreEqual(0, segs[746].Offset.ToDouble(), delta);
}
}
public void LoadMap01()
{
using (var wad = new Wad(WadPath.Doom2))
{
var flats = new DummyFlatLookup(wad);
var textures = new DummyTextureLookup(wad);
var map = wad.GetLumpNumber("MAP01");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
Assert.AreEqual(601, segs.Length);
Assert.IsTrue(segs[0].Vertex1 == vertices[9]);
Assert.IsTrue(segs[0].Vertex2 == vertices[316]);
Assert.AreEqual(ToRadian(-32768), segs[0].Angle.ToRadian(), delta);
Assert.IsTrue(segs[0].LineDef == lines[8]);
Assert.IsTrue((segs[0].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[0].FrontSector == segs[0].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[0].BackSector == segs[0].LineDef.BackSide.Sector);
Assert.AreEqual(0, segs[0].Offset.ToDouble(), delta);
Assert.IsTrue(segs[42].Vertex1 == vertices[26]);
Assert.IsTrue(segs[42].Vertex2 == vertices[320]);
Assert.AreEqual(ToRadian(-22209), segs[42].Angle.ToRadian(), delta);
Assert.IsTrue(segs[42].LineDef == lines[33]);
Assert.IsTrue((segs[42].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[42].FrontSector == segs[42].LineDef.BackSide.Sector);
Assert.IsTrue(segs[42].BackSector == segs[42].LineDef.FrontSide.Sector);
Assert.AreEqual(0, segs[42].Offset.ToDouble(), delta);
Assert.IsTrue(segs[103].Vertex1 == vertices[331]);
Assert.IsTrue(segs[103].Vertex2 == vertices[329]);
Assert.AreEqual(ToRadian(16384), segs[103].Angle.ToRadian(), delta);
Assert.IsTrue(segs[103].LineDef == lines[347]);
Assert.IsTrue((segs[103].LineDef.Flags & LineFlags.TwoSided) == 0);
Assert.IsTrue(segs[103].FrontSector == segs[103].LineDef.FrontSide.Sector);
Assert.IsTrue(segs[103].BackSector == null);
Assert.AreEqual(64, segs[103].Offset.ToDouble(), delta);
Assert.IsTrue(segs[600].Vertex1 == vertices[231]);
Assert.IsTrue(segs[600].Vertex2 == vertices[237]);
Assert.AreEqual(ToRadian(-16384), segs[600].Angle.ToRadian(), delta);
Assert.IsTrue(segs[600].LineDef == lines[271]);
Assert.IsTrue((segs[600].LineDef.Flags & LineFlags.TwoSided) != 0);
Assert.IsTrue(segs[600].FrontSector == segs[600].LineDef.BackSide.Sector);
Assert.IsTrue(segs[600].BackSector == segs[600].LineDef.FrontSide.Sector);
Assert.AreEqual(0, segs[600].Offset.ToDouble(), delta);
}
}
public static long[] OrganizingLottery5(long[] points, long[] startSegments,
long[] endSegment)
{
//write your code here
long[] result = new long[points.Length];
List <Seg> datas = new List <Seg>();
Seg s = new Seg();
for (int i = 0; i < points.Length; i++)
{
s.Key = 'p';
s.Value = points[i];
s.Index = i;
datas.Add(s);
}
for (int i = 0; i < startSegments.Length; i++)
{
s.Key = 'l';
s.Value = startSegments[i];
s.Index = 0;
datas.Add(s);
s.Key = 'r';
s.Value = endSegment[i];
s.Index = 0;
datas.Add(s);
}
datas = datas.OrderBy(x => x.Key).OrderBy(x => x.Value).ToList();
int cnt = 0;
foreach (var data in datas)
{
if (data.Key == 'l')
{
cnt++;
}
else if (data.Key == 'r')
{
cnt--;
}
else if (data.Key == 'p')
{
result[data.Index] = cnt;
}
}
return(result);
}
public Seg Alloc(int appendDateSize)
{
if (appendDateSize > blockSize)
{
throw new NotSupportedException();
}
if (Pool.TryPop(out var ret))
{
}
else
{
ret = new Seg(blockSize);
}
ret.len = (uint)appendDateSize;
return(ret);
}
public void Free(Seg seg)
{
seg.cmd = 0;
seg.conv = 0;
seg.fastack = 0;
seg.frg = 0;
seg.len = 0;
seg.resendts = 0;
seg.rto = 0;
seg.sn = 0;
seg.ts = 0;
seg.una = 0;
seg.wnd = 0;
seg.xmit = 0;
Pool.Push(seg);
}
bool RemergeTail(Seg hit)
{
// find the inactive tail that this bit is a part of
List <Seg> hitWorm = null;
foreach (var worm in worms)
{
// is the hit piece the tail or head of this tail?
if (hit == worm.GetFirst() || hit == worm.GetLast())
{
hitWorm = worm;
break;
}
}
if (hitWorm == null)
{
return(false);
}
else
{
// assimilate!
worms.Remove(hitWorm);
if (worm2key.ContainsKey(hitWorm))
{
int key = worm2key[hitWorm];
worm2key.Remove(hitWorm);
key2worm.Remove(key);
}
// reconnect so the new head is the OTHER end of the hit tail
if (hit == hitWorm.GetFirst())
{
hitWorm.Reverse();
}
activeWorm.GetFirst().isHead = false;
activeWorm.InsertRange(0, hitWorm);
foreach (var seg in activeWorm)
{
seg.isActive = true;
seg.isHead = false;
}
activeWorm.GetFirst().isHead = true;
return(true);
}
}
public void PointOnSegSide3()
{
var random = new Random(666);
for (var i = 0; i < 1000; i++)
{
var startX = -1 - 666 * random.NextDouble();
var endX = +1 + 666 * random.NextDouble();
var pointX = 666 * random.NextDouble() - 333;
var frontSideY = -1 - 666 * random.NextDouble();
var backSideY = -frontSideY;
for (var j = 0; j < 100; j++)
{
var theta = 2 * Math.PI * random.NextDouble();
var ox = 666 * random.NextDouble() - 333;
var oy = 666 * random.NextDouble() - 333;
var vertex1 = new Vertex(
Fixed.FromDouble(ox + startX * Math.Cos(theta)),
Fixed.FromDouble(oy + startX * Math.Sin(theta)));
var vertex2 = new Vertex(
vertex1.X + Fixed.FromDouble((endX - startX) * Math.Cos(theta)),
vertex1.Y + Fixed.FromDouble((endX - startX) * Math.Sin(theta)));
var seg = new Seg(
vertex1,
vertex2,
Fixed.Zero, Angle.Ang0, null, null, null, null);
{
var x = Fixed.FromDouble(ox + pointX * Math.Cos(theta) - frontSideY * Math.Sin(theta));
var y = Fixed.FromDouble(oy + pointX * Math.Sin(theta) + frontSideY * Math.Cos(theta));
Assert.AreEqual(0, Geometry.PointOnSegSide(x, y, seg));
}
{
var x = Fixed.FromDouble(ox + pointX * Math.Cos(theta) - backSideY * Math.Sin(theta));
var y = Fixed.FromDouble(oy + pointX * Math.Sin(theta) + backSideY * Math.Cos(theta));
Assert.AreEqual(1, Geometry.PointOnSegSide(x, y, seg));
}
}
}
}
/// <summary>
/// 進行斷詞，取回斷詞後的結果
/// </summary>
/// <param name="txt"></param>
/// <returns></returns>
public List <Pair <String, Int32> > SegWords(String txt)
{
Reader input = new StringReader(txt);
Seg seg = GetSeg();
MMSeg mmSeg = new MMSeg(input, seg);
Word word = null;
List <Pair <String, Int32> > result = new List <Pair <String, Int32> >();
while ((word = mmSeg.next()) != null)
{
// 兩種 Offset 方式
//word.getWordOffset();
//word.getStartOffset();
result.Add(new Pair <String, Int32>(word.getString(), word.getStartOffset()));
}
return(result);
}
Motion DistanceFromTarget(Seg s, Seg target)
{
Motion retVal = new Motion
{
P = (s - target).P,
rotation = s.rotation - target.rotation
};
while (retVal.rotation > PI)
{
retVal.rotation -= PI;
}
while (retVal.rotation < -PI)
{
retVal.rotation += PI;
}
return(retVal);
}
Seg NextPosition(Seg s, Motion m)
{
Seg retVal = new Seg
{
P = (s - m).P,
rotation = s.rotation - m.rotation,
};
while (retVal.rotation > PI)
{
retVal.rotation -= PI;
}
while (retVal.rotation < -PI)
{
retVal.rotation += PI;
}
return(retVal);
}
bool TryMoveWorm(List <Seg> worm, Int2 delta)
{
Seg head = worm.GetFirst();
Int2 nextDest = head.ent.pos;
if (!head.ent.TryMove(delta))
{
return(false);
}
else
{
// move all worm segments
for (int i = 1; i < worm.Count; i++)
{
var seg = worm[i];
Int2 temp = seg.ent.pos;
seg.ent.TryMove(nextDest - seg.ent.pos);
nextDest = temp;
}
return(true);
}
}
private void Apply()
{
_ownerTool.Show();
SegmentationComponent component = _ownerTool.GetActiveComponent();
if (component != null)
{
bool isLoaded = _ownerTool.EnsureSeriesIsLoaded(_info.DisplayImageSeriesUid,
_info.ImagePositionPatient,
_info.ImageOrientationPatient,
_info.FrameOfReferenceUid);
if (isLoaded)
{
Seg seg = component.SegFromDocumentUidAndSegNumber(_info.SegmentationDocumentUid,
_info.SegmentationNumber);
if (seg != null)
{
component.SegmentationTree.SelectedSeg = seg;
component.ShowImageContainingSeg(seg);
}
}
}
}
/// <summary>This method builds a Conformance Segment Class</summary>
/// <param name="seg">the Segment to build
/// </param>
/// <param name="parentUnderlyingType">the data type of the parent Message or SegGroup for this segment
/// example "Genetibase.NuGenHL7.model.v24.group.ADR_A19_..."
/// </param>
/// <param name="profileName">this is the profile name associated with this Class
/// </param>
public virtual void buildClass(Seg seg, System.String parentUnderlyingType, ProfileName profileName)
{
GeneratedConformanceContainer gcc = new GeneratedConformanceContainer();
System.String underlyingDataType; // The underlying HAPI Type
// Check for possible snags in the Runtime Profile Segment
if (seg.Name == null || seg.Name.Length < 1)
{
throw new ConformanceError("Error building ConformanceSegment: Runtime Segment does not contain a name.");
}
// Set up class
gcc.ClassPackage = packageName;
gcc.addClassImport("Genetibase.NuGenHL7.conf.classes.abs.*");
gcc.addClassImport("Genetibase.NuGenHL7.conf.classes.exceptions.*");
gcc.addClassImport("Genetibase.NuGenHL7.*");
gcc.addClassImport(packageName + "." + profileName.PackageName + ".*");
gcc.Name = profileName.ClassName;
gcc.Properties = "extends AbstractConformanceContainer implements Repeatable";
gcc.setMinMaxReps(seg.Min, seg.Max);
underlyingDataType = "Genetibase.NuGenHL7.model." + versionString + ".segment." + seg.Name;
System.String segClassName = UnderlyingAccessor.getHapiModelClass(underlyingDataType).FullName;
gcc.addMemberVariable("private " + segClassName + " hapiSegment;");
docBuilder.decorateConstructor(gcc.Constructor, profileName.ClassName);
// Set up underlying Segment type
GeneratedMethod theConstructor = gcc.Constructor;
theConstructor.addParam(parentUnderlyingType + " underlyingMessage", "The underlying message object");
theConstructor.addParam("int rep", "The underlying rep number");
UnderlyingAccessor underlyingAccessor = new UnderlyingAccessor(parentUnderlyingType, profileName.AccessorName);
theConstructor.addToBody("this.hapiSegment = (" + segClassName + ") underlyingMessage." + underlyingAccessor.ToString() + ";");
theConstructor.addToThrows("HL7Exception");
// Loop through each child. Note that array is 1-offset
for (int i = 1; i <= seg.Fields; i++)
{
//don't build not supported, backward, or unknown types
System.String usage = seg.getField(i).Usage;
if (usage != null && (usage.Equals("X") || usage.Equals("B") || usage.Equals("U")))
{
continue;
}
// Create the names for each type of child
// //CHANGED to use field # instead of name, in support of Z-segments
// ProfileName childProfileName = profileName.newInstance(String.valueOf(i), ProfileName.PS_FIELD);
ProfileName childProfileName = profileName.newInstance(seg.getField(i).Name, ProfileName.PS_FIELD);
// Add the member variable vector to hold them
gcc.addMemberVariable("private FiniteList " + childProfileName.MemberName + ";");
// Set up the constructor
theConstructor.addToBody(childProfileName.MemberName + " = new FiniteList( " + childProfileName.ClassName + ".class, hapiSegment );");
// Add the getter
UnderlyingAccessor childAccessor = new UnderlyingAccessor(underlyingDataType, childProfileName.AccessorName);
GeneratedRepGetter repGetter = new GeneratedRepGetter(childProfileName, childAccessor.AcceptsRep);
docBuilder.decorateRepGetter(repGetter, seg.getField(i), childProfileName.ClassName);
gcc.addMethod(repGetter);
// If the field has no components it is a primitive, so build as such.
if (seg.getField(i).Components > 0)
{
ConformanceFieldBuilder childBuilder = new ConformanceFieldBuilder(packageName + "." + profileName.PackageName, versionString, depManager);
childBuilder.buildClass(seg.getField(i), segClassName, childProfileName.clearNameMap());
}
else
{
ConformancePrimitiveBuilder childBuilder = new ConformancePrimitiveBuilder(packageName + "." + profileName.PackageName, depManager);
childBuilder.buildClass(seg.getField(i), segClassName, childProfileName.clearNameMap());
}
}
// Decorate with comments
docBuilder.decorateSegment(gcc, seg);
if (depManager.Verbose)
{
System.Console.Out.WriteLine("Generating Segment: " + packageName + "." + gcc.Name);
}
depManager.generateFile(gcc, packageName, profileName.ClassName);
}
static bool ContainsAnyVertices(LEV.Sector sector, Seg seg0, Seg seg1, Seg seg2)
{
Vector2 a = sector.Vertices[seg0.IdxA];
Vector2 b = sector.Vertices[seg0.IdxB];
Vector2 c;
if ((seg1.IdxA != seg0.IdxA) && (seg1.IdxA != seg0.IdxB)) {
c = sector.Vertices[seg1.IdxA];
} else {
c = sector.Vertices[seg1.IdxB];
}
for (int i = 0; i < sector.Vertices.Count; ++i) {
if ((seg0.IdxA != i) && (seg0.IdxB != i) &&
(seg1.IdxA != i) && (seg1.IdxB != i) &&
(seg2.IdxA != i) && (seg2.IdxB != i)) {
Vector2 p = sector.Vertices[i];
if (PointInTriangle(p, a, b, c)) {
return true;
}
}
}
return false;
}
static bool TrySegToVertex(LEV.Sector sector, LinkedList<Seg> segs, Seg seg, int index, List<int> counts, List<int> outTris, bool debugDraw)
{
// bad sector: inward facing wall
if ((FindSeg(segs, seg.IdxA, index) != null) ||
(FindSeg(segs, index, seg.IdxB) != null)) {
return false;
}
// does this vertex cross any segs?
Seg addSeg0 = new Seg(sector, seg.IdxA, index, -1);
foreach (var testSeg in segs) {
if (seg != testSeg) {
if (addSeg0.Intersects(testSeg)) {
return false;
}
}
}
Seg addSeg1 = new Seg(sector, index, seg.IdxB, -1);
foreach (var testSeg in segs) {
if (seg != testSeg) {
if (addSeg1.Intersects(testSeg)) {
return false;
}
}
}
if (ContainsAnyVertices(sector, seg, addSeg0, addSeg1)) {
return false;
}
// seg + seg + vertex creates valid triangle
outTris.Add(seg.IdxA);
outTris.Add(seg.IdxB);
outTris.Add(index);
segs.AddFirst(addSeg0);
segs.AddFirst(addSeg1);
segs.Remove(seg);
Incr(counts, index, 2);
if (debugDraw) {
DebugDrawStep(sector, segs, addSeg0, addSeg1, outTris);
_segSteps.Add(CopySegList(sector, segs));
}
return true;
}
public static void CreateSeriesGraphicsForSeg(IPresentationImage presentationImage, Seg seg,
SegmentationDocument segmentationDocument,
IDicomMessageSopDataSource dicomMessageSopDataSourceSop)
{
Platform.CheckForNullReference(presentationImage, "presentationImage");
Platform.CheckForNullReference(seg, "seg");
Platform.CheckForNullReference(segmentationDocument, "segmentationDocument");
SegmentImageData segImageData = seg.SegmentImageData;
if (segImageData == null)
{
Platform.Log(LogLevel.Error,
"Cannot create segmentation graphics when no segmentation imaging data is provided");
return;
}
var imageSopProvider = presentationImage as IImageSopProvider;
if (imageSopProvider == null)
{
Platform.Log(LogLevel.Error,
"Failed to populate SegFrameGraphics collection. Image is not an ImageSopProvider");
return;
}
DicomPixelData segmentationPixelData = DicomPixelData.CreateFrom(dicomMessageSopDataSourceSop.SourceMessage);
var rawPixelData =
(byte[])dicomMessageSopDataSourceSop.SourceMessage.DataSet.GetAttribute(DicomTags.PixelData).Values;
var pixelDataGetter = new Func <int, byte[]>(frameIndex =>
{
if (segImageData.BitsStored == 1)
{
// Do unpacking
int frameLength = segImageData.Rows *
segImageData.Columns;
var overlayData =
new OverlayData(frameIndex * frameLength,
segImageData.Rows,
segImageData.Columns, false,
rawPixelData);
return(overlayData.Unpack());
}
if (segImageData.BitsStored == 8)
{
return(segmentationPixelData.GetFrame(frameIndex));
}
throw new InvalidDataException(
"Segmentation objects need to have BitsStored as either 1 or 8");
});
// NOTE: SegmentFrameData was already sorted
foreach (SegmentFrameData segmentFrameData in segImageData.SegmentFrameData)
{
IPresentationImage segPresentationImage = null;
// Get the presentation image if we have an image reference
string referencedSopInstanceUid = segmentFrameData.ReferencedSopInstanceUid;
int referencedImageFrameNumber = segmentFrameData.ReferencedFrameNumber ?? 1;
if (!string.IsNullOrEmpty(referencedSopInstanceUid))
{
segPresentationImage =
presentationImage.ParentDisplaySet.PresentationImages.OfType <IImageSopProvider>()
.FirstOrDefault(curImageSopProvider => curImageSopProvider != null &&
curImageSopProvider.ImageSop.SopInstanceUid ==
referencedSopInstanceUid &&
curImageSopProvider.Frame.FrameNumber ==
referencedImageFrameNumber) as IPresentationImage;
}
// Location defaults to 0, 0 unless determined otherwise from image position and image orientation
var segLocation = new PointF();
// Get the presentation image from the image position and orientation
if (segmentFrameData.ImagePositionPatient != null &&
segmentFrameData.ImagePositionPatient.Count() > 2 &&
segmentFrameData.ImageOrientationPatient != null &&
segmentFrameData.ImageOrientationPatient.Count() > 5)
{
var imagePositionPatient = new ImagePositionPatient(
segmentFrameData.ImagePositionPatient[0],
segmentFrameData.ImagePositionPatient[1],
segmentFrameData.ImagePositionPatient[2]);
var imageOrientationPatient = new ImageOrientationPatient(
segmentFrameData.ImageOrientationPatient[0],
segmentFrameData.ImageOrientationPatient[1],
segmentFrameData.ImageOrientationPatient[2],
segmentFrameData.ImageOrientationPatient[3],
segmentFrameData.ImageOrientationPatient[4],
segmentFrameData.ImageOrientationPatient[5]);
IDisplaySet displaySet = presentationImage.ParentDisplaySet;
if (segPresentationImage == null)
{
segPresentationImage = PresentationImageFromPositionOrientation(
imagePositionPatient,
imageOrientationPatient,
displaySet,
segImageData.FrameOfReferenceUid);
}
var imageSop = segPresentationImage as IImageSopProvider;
if (imageSop != null)
{
Vector3D segImageLocation =
imageSop.Frame.ImagePlaneHelper.ConvertToImagePlane(new Vector3D(
(float)imagePositionPatient.X,
(float)imagePositionPatient.Y,
(float)imagePositionPatient.Z));
PointF?segPixelLocation =
imageSop.Frame.ImagePlaneHelper.ConvertToImage(
new PointF(segImageLocation.X, segImageLocation.Y));
if (segPixelLocation.HasValue)
{
segLocation = segPixelLocation.Value;
}
}
}
if (segPresentationImage != null)
{
SegFrameImageGraphic newGraphic = AddSegFrameImageGraphicToPresentationImage(
segPresentationImage,
segImageData.Rows,
segImageData.Columns,
segLocation.X,
segLocation.Y,
seg.Color,
referencedImageFrameNumber,
seg.Label,
seg.Description,
pixelDataGetter.Invoke(segmentFrameData.FrameNumber - 1),
new SegmentationDocumentReference(segmentationDocument, seg.SegmentationNumber));
if (newGraphic != null &&
segPresentationImage == segPresentationImage.ParentDisplaySet.ImageBox.TopLeftPresentationImage)
{
newGraphic.Draw();
}
}
else
{
Platform.Log(LogLevel.Error, "Failed to find Presentation Image to display a segment on");
}
}
}
private void BuildPath
(
PdfContents Contents,
PaintOp PaintOperator
)
{
// every figure is a separated subpath and contains some segments
foreach (SysMedia.PathFigure SubPath in MediaPath.Figures)
{
// get start of sub-path point
PointD CurPoint = PathToDrawing(SubPath.StartPoint);
PointD StartPoint = CurPoint;
Contents.MoveTo(CurPoint);
// process all points of one sub-path
foreach (SysMedia.PathSegment Seg in SubPath.Segments)
{
// line segment
if (Seg.GetType() == typeof(SysMedia.LineSegment))
{
CurPoint = PathToDrawing(((SysMedia.LineSegment)Seg).Point);
Contents.LineTo(CurPoint);
}
// polygon
else if (Seg.GetType() == typeof(SysMedia.PolyLineSegment))
{
SysMedia.PolyLineSegment LineSegArray = (SysMedia.PolyLineSegment)Seg;
foreach (SysWin.Point PolyPoint in LineSegArray.Points)
{
CurPoint = PathToDrawing(PolyPoint);
Contents.LineTo(CurPoint);
}
}
// cubic bezier segment
else if (Seg.GetType() == typeof(SysMedia.BezierSegment))
{
SysMedia.BezierSegment BezierSeg = (SysMedia.BezierSegment)Seg;
CurPoint = PathToDrawing(BezierSeg.Point3);
Contents.DrawBezier(PathToDrawing(BezierSeg.Point1), PathToDrawing(BezierSeg.Point2), CurPoint);
}
// cubic bezier multi segments
else if (Seg.GetType() == typeof(SysMedia.PolyBezierSegment))
{
SysMedia.PolyBezierSegment BezierSegArray = (SysMedia.PolyBezierSegment)Seg;
int Count = BezierSegArray.Points.Count;
for (int Index = 0; Index < Count; Index += 3)
{
CurPoint = PathToDrawing(BezierSegArray.Points[Index + 2]);
Contents.DrawBezier(PathToDrawing(BezierSegArray.Points[Index]), PathToDrawing(BezierSegArray.Points[Index + 1]), CurPoint);
}
}
// quadratic bezier segment
else if (Seg.GetType() == typeof(SysMedia.QuadraticBezierSegment))
{
SysMedia.QuadraticBezierSegment BezierSeg = (SysMedia.QuadraticBezierSegment)Seg;
PointD NextPoint = PathToDrawing(BezierSeg.Point2);
Contents.DrawBezier(new BezierD(CurPoint, PathToDrawing(BezierSeg.Point1), NextPoint), BezierPointOne.Ignore);
CurPoint = NextPoint;
}
// quadratic bezier multi segments
else if (Seg.GetType() == typeof(SysMedia.PolyQuadraticBezierSegment))
{
SysMedia.PolyQuadraticBezierSegment BezierSegArray = (SysMedia.PolyQuadraticBezierSegment)Seg;
int Count = BezierSegArray.Points.Count;
for (int Index = 0; Index < Count; Index += 2)
{
PointD NextPoint = PathToDrawing(BezierSegArray.Points[Index + 1]);
Contents.DrawBezier(new BezierD(CurPoint, PathToDrawing(BezierSegArray.Points[Index]), NextPoint), BezierPointOne.Ignore);
CurPoint = NextPoint;
}
}
// draw arc
else if (Seg.GetType() == typeof(SysMedia.ArcSegment))
{
SysMedia.ArcSegment Arc = (SysMedia.ArcSegment)Seg;
PointD NextPoint = PathToDrawing(Arc.Point);
ArcType ArcType;
if (Arc.SweepDirection == (PathYAxis == YAxisDirection.Down ? SysMedia.SweepDirection.Counterclockwise : SysMedia.SweepDirection.Clockwise))
{
ArcType = Arc.IsLargeArc ? ArcType.LargeCounterClockWise : ArcType.SmallCounterClockWise;
}
else
{
ArcType = Arc.IsLargeArc ? ArcType.LargeClockWise : ArcType.SmallClockWise;
}
Contents.DrawArc(CurPoint, NextPoint, SizeToDrawing(Arc.Size), Arc.RotationAngle, ArcType, BezierPointOne.Ignore);
CurPoint = NextPoint;
}
// should no happen
else
{
throw new ApplicationException("Windows Media path: unknown path segment.");
}
}
// for stroke set paint operator for each sub-path
if (SubPath.IsClosed)
{
Contents.SetPaintOp(PaintOp.CloseSubPath);
}
}
// paint operator
Contents.SetPaintOp(PaintOperator);
return;
}
static int FindVertex(LEV.Sector sector, Seg seg, List<int> verts)
{
// find closest vertex in front of line
float bestDist = float.MaxValue;
int bestIndex = -1;
foreach (var i in verts) {
Vector2 p = sector.Vertices[i];
float d = seg.Distance(p);
if (d > 0f) {
float d0 = (p-seg.A).sqrMagnitude;
float d1 = (p-seg.B).sqrMagnitude;
d = Mathf.Min(d0, d1);
if (d < bestDist) {
bestIndex = i;
bestDist = d;
}
}
}
return bestIndex;
}
static bool TrySegToSeg(LEV.Sector sector, LinkedList<Seg> segs, Seg seg0, Seg seg1, List<int> counts, List<int> outTris, bool debugDraw)
{
if (!seg0.InFront(seg1.B)) {
// concave angle
return false;
}
// does this vertex cross any segs?
LinkedListNode<Seg> existingSeg = FindSeg(segs, seg1.IdxB, seg0.IdxA);
Seg addSeg0;
if (existingSeg == null) {
if (FindSeg(segs, seg0.IdxA, seg1.IdxB) != null) {
// bad-sector: inward facing wall.
return false;
}
addSeg0 = new Seg(sector, seg0.IdxA, seg1.IdxB, -1);
} else {
addSeg0 = existingSeg.Value;
}
if (existingSeg == null) {
foreach (var testSeg in segs) {
if ((seg0 != testSeg) && (seg1 != testSeg)) {
if (addSeg0.Intersects(testSeg)) {
return false;
}
}
}
}
if (ContainsAnyVertices(sector, seg0, seg1, addSeg0)) {
return false;
}
// seg + seg create valid triangle
outTris.Add(seg1.IdxA);
outTris.Add(seg1.IdxB);
outTris.Add(seg0.IdxA);
segs.Remove(seg0);
segs.Remove(seg1);
if (existingSeg != null) {
Incr(counts, seg0.IdxA, -2);
Incr(counts, seg0.IdxB, -2);
Incr(counts, seg1.IdxB, -2);
segs.Remove(existingSeg);
if (debugDraw) {
DebugDrawStep(sector, segs, null, null, outTris);
_segSteps.Add(CopySegList(sector, segs));
}
} else {
segs.AddFirst(addSeg0);
Incr(counts, seg0.IdxB, -2);
if (debugDraw) {
DebugDrawStep(sector, segs, addSeg0, null, outTris);
_segSteps.Add(CopySegList(sector, segs));
}
}
return true;
}
public void LoadMap01()
{
using (var wad = new Wad(WadPath.Doom2))
{
var flats = new FlatLookup(wad, true);
var textures = new TextureLookup(wad, true);
var map = wad.GetLumpNumber("MAP01");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
var subsectors = Subsector.FromWad(wad, map + 6, segs);
var nodes = Node.FromWad(wad, map + 7, subsectors);
Assert.AreEqual(193, nodes.Length);
Assert.AreEqual(64, nodes[0].X.ToDouble(), delta);
Assert.AreEqual(1024, nodes[0].Y.ToDouble(), delta);
Assert.AreEqual(0, nodes[0].Dx.ToDouble(), delta);
Assert.AreEqual(-64, nodes[0].Dy.ToDouble(), delta);
Assert.AreEqual(1173, nodes[0].Bbox[0][Box.Top].ToDouble(), delta);
Assert.AreEqual(960, nodes[0].Bbox[0][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(-64, nodes[0].Bbox[0][Box.Left].ToDouble(), delta);
Assert.AreEqual(64, nodes[0].Bbox[0][Box.Right].ToDouble(), delta);
Assert.AreEqual(1280, nodes[0].Bbox[1][Box.Top].ToDouble(), delta);
Assert.AreEqual(1024, nodes[0].Bbox[1][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(64, nodes[0].Bbox[1][Box.Left].ToDouble(), delta);
Assert.AreEqual(128, nodes[0].Bbox[1][Box.Right].ToDouble(), delta);
Assert.AreEqual(32770, nodes[0].Children[0] + 0x10000);
Assert.AreEqual(32771, nodes[0].Children[1] + 0x10000);
Assert.AreEqual(640, nodes[57].X.ToDouble(), delta);
Assert.AreEqual(856, nodes[57].Y.ToDouble(), delta);
Assert.AreEqual(-88, nodes[57].Dx.ToDouble(), delta);
Assert.AreEqual(-16, nodes[57].Dy.ToDouble(), delta);
Assert.AreEqual(856, nodes[57].Bbox[0][Box.Top].ToDouble(), delta);
Assert.AreEqual(840, nodes[57].Bbox[0][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(552, nodes[57].Bbox[0][Box.Left].ToDouble(), delta);
Assert.AreEqual(640, nodes[57].Bbox[0][Box.Right].ToDouble(), delta);
Assert.AreEqual(856, nodes[57].Bbox[1][Box.Top].ToDouble(), delta);
Assert.AreEqual(760, nodes[57].Bbox[1][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(536, nodes[57].Bbox[1][Box.Left].ToDouble(), delta);
Assert.AreEqual(704, nodes[57].Bbox[1][Box.Right].ToDouble(), delta);
Assert.AreEqual(32829, nodes[57].Children[0] + 0x10000);
Assert.AreEqual(56, nodes[57].Children[1]);
Assert.AreEqual(96, nodes[192].X.ToDouble(), delta);
Assert.AreEqual(1280, nodes[192].Y.ToDouble(), delta);
Assert.AreEqual(32, nodes[192].Dx.ToDouble(), delta);
Assert.AreEqual(0, nodes[192].Dy.ToDouble(), delta);
Assert.AreEqual(1280, nodes[192].Bbox[0][Box.Top].ToDouble(), delta);
Assert.AreEqual(-960, nodes[192].Bbox[0][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(-1304, nodes[192].Bbox[0][Box.Left].ToDouble(), delta);
Assert.AreEqual(2072, nodes[192].Bbox[0][Box.Right].ToDouble(), delta);
Assert.AreEqual(2688, nodes[192].Bbox[1][Box.Top].ToDouble(), delta);
Assert.AreEqual(1280, nodes[192].Bbox[1][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(-1304, nodes[192].Bbox[1][Box.Left].ToDouble(), delta);
Assert.AreEqual(2072, nodes[192].Bbox[1][Box.Right].ToDouble(), delta);
Assert.AreEqual(147, nodes[192].Children[0]);
Assert.AreEqual(191, nodes[192].Children[1]);
}
}
void GoToGoal(Segment sCurrent, Segment sTarget)
{
//instead of working with endpoints, we'll just work with midpoint and rotation because the length can't change
Seg pCurrent = new Seg {
P = sCurrent.MidPoint.P, rotation = sCurrent.Angle
};
Seg pTarget = new Seg {
P = sTarget.MidPoint.P, rotation = sTarget.Angle
};
Motion neededMotion = DistanceFromTarget(pTarget, pCurrent);
//there are two exit cases...here we test for absolute closeness, below we test for the best action makes thing further
if (Abs(neededMotion.rotation) < .05 && Abs(neededMotion.X) < .1 && Abs(neededMotion.Y) < .1)
{
endTarget = null;
}
else
{
ModuleUKSN UKS = (ModuleUKSN)FindModleu(typeof(ModuleUKSN));
Thing bestEvent = null;
if (neededMotion.R > .2f)
{
//create a temp distination which is slightly offset
ModuleBehavior mBehavior = (ModuleBehavior)FindModleu(typeof(ModuleBehavior));
Seg tempTarget = new Seg()
{
P = sTarget.MidPoint.P + new PointPlus {
R = .15f, Theta = sTarget.Angle - PI / 2
}.V, rotation = 0
};
neededMotion = DistanceFromTarget(tempTarget, pCurrent);
bestEvent = UKS.Labeled("E0");
if (neededMotion.Theta < -.05)
{
bestEvent = UKS.Labeled("E2");
}
if (neededMotion.Theta > .05)
{
bestEvent = UKS.Labeled("E1");
}
}
else if (neededMotion.R > .01)
{
if (neededMotion.rotation < -.02)
{
bestEvent = UKS.Labeled("E2");
}
else
{
bestEvent = UKS.Labeled("E1");
}
}
if (bestEvent != null)
{
Motion m = (Motion)bestEvent.Children[0].References[1].T.V;
Seg nextPosition = NextPosition(pCurrent, (Motion)bestEvent.Children[0].References[1].T.V);
Motion next = DistanceFromTarget(pTarget, nextPosition);
//if (next.R < neededMotion.R || Abs(next.rotation) > Utils.Rad(5))
{
GoToLandmark(bestEvent.References[0].T, sCurrent);
doPush = 2;
doBackOff = true;
}
//// else
// {
// endTarget = null;
// }
}
//find the event with the most desireable outcome and then go the the landmark.
//Thing bestEvent = null;
//List<Thing> events = UKS.Labeled("Event").Children;
//Seg[] distances = new Seg[events.Count];
////first time through loop initialize array and take first action
//for (int i = 0; i < events.Count; i++)
//{
// distances[i] = new Seg() { P = neededMotion.P, rotation = neededMotion.rotation };
// Thing tEvent = events[i];
// Motion motion = (Motion)tEvent.Children[0].References[1].T.V;
// distances[i] = NextPosition(distances[i], motion);
//}
////second time through loop, add to array
//for (int j = 0; j < 3; j++) //three steps
//{
// for (int i = 0; i < events.Count; i++)
// {
// for (int k = 0; k < events.Count; k++)
// {
// Thing tEvent = events[k];
// Motion motion = (Motion)tEvent.Children[0].References[1].T.V;
// Seg newS = NextPosition(distances[i], motion);
// if (newS.Val < distances[i].Val)
// { distances[i] = newS; }
// }
// }
//}
//float bestDist = float.MaxValue;
//for (int i = 0; i < events.Count; i++) //last time through loop, find best
//{
// if (distances[i].Val < bestDist)
// {
// bestDist = distances[i].Val;
// bestEvent = events[i];
// }
//}
//Motion motion1 = (Motion)bestEvent.Children[0].References[1].T.V;
//Seg newS1 = NextPosition(pCurrent, motion1);
//if (newS1.Val < pTarget.Val)
//{
// GoToLandmark(bestEvent.References[0].T, sCurrent);
// doPush = 2;
// doBackOff = true;
//}
//else //our best move makes things worse
//{
// endTarget = null;
//}
}
}
public bool Intersects(Seg other)
{
float d = Vector2.Dot(N, other.N);
if (Mathf.Abs(d) > 0.9999) {
return false; // parallel
}
float SA = Distance(other.A);
float SB = Distance(other.B);
if ((SA <= 0.01f) && (SB <= 0.01f)) {
return false;
}
if ((SA >= -0.01f) && (SB >= -0.01f)) {
return false;
}
Vector2 p = Vector2.Lerp(other.A, other.B, Mathf.Abs(SA) / ((Mathf.Abs(SA)+Mathf.Abs(SB))));
return IsPointOnLine(p) && other.IsPointOnLine(p);
}
///// ------------------------------------------------------------------------------------
///// <summary>
///// Copies to this instance the information from the specified translation unit.
///// </summary>
///// ------------------------------------------------------------------------------------
//public void Copy(TransUnitVariant tuv)
//{
// Value = tuv.Value;
// Lang = tuv.Lang;
// DataType = tuv.DataType;
// m_notes = (from note in tuv.Notes
// select new TMXNote { Text = note.Text, Lang = note.Lang }).ToList();
// m_props = (from prop in tuv.Props
// select new TMXProp { Type = prop.Type, Value = prop.Value, Lang = prop.Lang }).ToList();
//}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Clears all the value. Using the setter to assign the Value property will append
/// to the existing values. That is because a translation unit may have more than
/// one 'seg' element.
/// </summary>
/// ------------------------------------------------------------------------------------
public void ClearValue()
{
Seg.ClearValue();
}
static void DebugDrawStep(LEV.Sector sector, IEnumerable<Seg> newSegs, Seg newSeg0, Seg newSeg1, List<int> outTris)
{
foreach (var list in _segSteps) {
foreach (var seg in list) {
DrawSeg(seg, Color.green);
}
}
foreach (var seg in newSegs) {
if ((seg != newSeg0) && (seg != newSeg1)) {
DrawSeg(seg, Color.red);
}
}
if (outTris.Count >= 3) {
int idx = outTris.Count - 3;
Vector2 x = sector.Vertices[outTris[idx]];
Vector2 y = sector.Vertices[outTris[idx+1]];
Vector2 z = sector.Vertices[outTris[idx+2]];
Vector3 a = new Vector3(x.x, _debugRenderOffset, x.y);
Vector3 b = new Vector3(y.x, _debugRenderOffset, y.y);
Vector3 c = new Vector3(z.x, _debugRenderOffset, z.y);
Debug.DrawLine(a, b, Color.yellow, float.MaxValue);
Debug.DrawLine(b, c, Color.yellow, float.MaxValue);
Debug.DrawLine(c, a, Color.yellow, float.MaxValue);
}
if (newSeg0 != null) {
Vector3 a = new Vector3(newSeg0.A.x, _debugRenderOffset, newSeg0.A.y);
Vector3 b = new Vector3(newSeg0.B.x, _debugRenderOffset, newSeg0.B.y);
Debug.DrawLine(a, b, Color.magenta, float.MaxValue);
}
if (newSeg1 != null) {
Vector3 a = new Vector3(newSeg1.A.x, _debugRenderOffset, newSeg1.A.y);
Vector3 b = new Vector3(newSeg1.B.x, _debugRenderOffset, newSeg1.B.y);
Debug.DrawLine(a, b, Color.magenta, float.MaxValue);
}
_debugRenderOffset += 16f;
}
static void DrawSeg(Seg seg, Color color)
{
Vector3 a = new Vector3(seg.A.x, _debugRenderOffset, seg.A.y);
Vector3 b = new Vector3(seg.B.x, _debugRenderOffset, seg.B.y);
Debug.DrawLine(a, b, color, float.MaxValue);
Vector2 mid = Vector2.Lerp(seg.A, seg.B, 0.5f);
Vector2 nml = mid + seg.N*0.15f;
a = new Vector3(mid.x, _debugRenderOffset, mid.y);
b = new Vector3(nml.x, _debugRenderOffset, nml.y);
Debug.DrawLine(a, b, color, float.MaxValue);
}
static List<LinkedListNode<Seg>> FindConnectedSegs(LinkedList<Seg> segs, Seg seg, int vert)
{
List<LinkedListNode<Seg>> list = null;
for (var node = segs.First; node != null; node = node.Next) {
Seg testSeg = node.Value;
if ((testSeg != seg) && ((testSeg.IdxA == vert) || (testSeg.IdxB == vert))) {
if (list == null) {
list = new List<LinkedListNode<Seg>>();
}
list.Add(node);
}
}
return list;
}
public void LoadE1M1()
{
using (var wad = new Wad(WadPath.Doom1))
{
var flats = new FlatLookup(wad, true);
var textures = new TextureLookup(wad, true);
var map = wad.GetLumpNumber("E1M1");
var vertices = Vertex.FromWad(wad, map + 4);
var sectors = Sector.FromWad(wad, map + 8, flats);
var sides = SideDef.FromWad(wad, map + 3, textures, sectors);
var lines = LineDef.FromWad(wad, map + 2, vertices, sides);
var segs = Seg.FromWad(wad, map + 5, vertices, lines);
var subsectors = Subsector.FromWad(wad, map + 6, segs);
var nodes = Node.FromWad(wad, map + 7, subsectors);
Assert.AreEqual(238, nodes.Length);
Assert.AreEqual(1784, nodes[0].X.ToDouble(), delta);
Assert.AreEqual(-3448, nodes[0].Y.ToDouble(), delta);
Assert.AreEqual(-240, nodes[0].Dx.ToDouble(), delta);
Assert.AreEqual(64, nodes[0].Dy.ToDouble(), delta);
Assert.AreEqual(-3104, nodes[0].Bbox[0][Box.Top].ToDouble(), delta);
Assert.AreEqual(-3448, nodes[0].Bbox[0][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(1520, nodes[0].Bbox[0][Box.Left].ToDouble(), delta);
Assert.AreEqual(2128, nodes[0].Bbox[0][Box.Right].ToDouble(), delta);
Assert.AreEqual(-3384, nodes[0].Bbox[1][Box.Top].ToDouble(), delta);
Assert.AreEqual(-3448, nodes[0].Bbox[1][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(1544, nodes[0].Bbox[1][Box.Left].ToDouble(), delta);
Assert.AreEqual(1784, nodes[0].Bbox[1][Box.Right].ToDouble(), delta);
Assert.AreEqual(32768, nodes[0].Children[0] + 0x10000);
Assert.AreEqual(32769, nodes[0].Children[1] + 0x10000);
Assert.AreEqual(928, nodes[57].X.ToDouble(), delta);
Assert.AreEqual(-3360, nodes[57].Y.ToDouble(), delta);
Assert.AreEqual(0, nodes[57].Dx.ToDouble(), delta);
Assert.AreEqual(256, nodes[57].Dy.ToDouble(), delta);
Assert.AreEqual(-3104, nodes[57].Bbox[0][Box.Top].ToDouble(), delta);
Assert.AreEqual(-3360, nodes[57].Bbox[0][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(928, nodes[57].Bbox[0][Box.Left].ToDouble(), delta);
Assert.AreEqual(1344, nodes[57].Bbox[0][Box.Right].ToDouble(), delta);
Assert.AreEqual(-3104, nodes[57].Bbox[1][Box.Top].ToDouble(), delta);
Assert.AreEqual(-3360, nodes[57].Bbox[1][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(704, nodes[57].Bbox[1][Box.Left].ToDouble(), delta);
Assert.AreEqual(928, nodes[57].Bbox[1][Box.Right].ToDouble(), delta);
Assert.AreEqual(32825, nodes[57].Children[0] + 0x10000);
Assert.AreEqual(56, nodes[57].Children[1]);
Assert.AreEqual(2176, nodes[237].X.ToDouble(), delta);
Assert.AreEqual(-2304, nodes[237].Y.ToDouble(), delta);
Assert.AreEqual(0, nodes[237].Dx.ToDouble(), delta);
Assert.AreEqual(-256, nodes[237].Dy.ToDouble(), delta);
Assert.AreEqual(-2048, nodes[237].Bbox[0][Box.Top].ToDouble(), delta);
Assert.AreEqual(-4064, nodes[237].Bbox[0][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(-768, nodes[237].Bbox[0][Box.Left].ToDouble(), delta);
Assert.AreEqual(2176, nodes[237].Bbox[0][Box.Right].ToDouble(), delta);
Assert.AreEqual(-2048, nodes[237].Bbox[1][Box.Top].ToDouble(), delta);
Assert.AreEqual(-4864, nodes[237].Bbox[1][Box.Bottom].ToDouble(), delta);
Assert.AreEqual(2176, nodes[237].Bbox[1][Box.Left].ToDouble(), delta);
Assert.AreEqual(3808, nodes[237].Bbox[1][Box.Right].ToDouble(), delta);
Assert.AreEqual(131, nodes[237].Children[0]);
Assert.AreEqual(236, nodes[237].Children[1]);
}
}
public bool SharesVertex(Seg other)
{
return (IdxA == other.IdxA) || (IdxB == other.IdxA) ||
(IdxA == other.IdxB) || (IdxB == other.IdxB);
}
