using System.

IO;
using [Link];
using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using Application = [Link];
using Polyline = [Link];
using [Link];
using [Link];
using [Link];
using [Link];

using Exception = [Link];

using OpenMode = [Link];

using [Link];
using [Link];
using [Link];
using [Link];
using Viewport = [Link];

namespace [Link]
{
public class CClass
{

public class Point2

{
public Point3d LatLongFromPoint2(Point3d P)
{

var doc = [Link];

var ed = [Link];
var db = [Link];

var lonlat = TranslateGeoPoint(db, P, true);

var p = new Point3d(lonlat.X, lonlat.Y, 0);

return p;
}

//public Point2d LatLongFromPoint2(Point2d P)

//{
// var doc = [Link];

// var ed = [Link];
// var db = [Link];

// var lonlat = TranslateGeoPoint(db, P, true);

// var p = new Point2d(lonlat.X, lonlat.Y);

// return p;
//}
 public Point3d LatLongFromPoint2d(Point3d P)
{
var doc = [Link];

var ed = [Link];
var db = [Link];

var lonlat = TranslateGeoPoint(db, P, true);

var p = new Point3d(lonlat.X, lonlat.Y, 0);

return p;
}

private Point3d TranslateGeoPoint(Database db, Point3d inPt, bool fromDwg)

{
using (var tr = [Link]())
{
// Get the drawing's GeoLocation object

var gd = [Link]([Link], [Link]) as

GeoLocationData;

// Get the output point...

// dwg2lonlat if fromDwg is true,
// lonlat2dwg otherwise

var outPt = (fromDwg ? [Link](inPt) :

[Link](inPt));

[Link]();

return outPt;
}
}

public Point3d PointFromLatLong(Point3d Point)

{
var doc = [Link];
var db = [Link];

// Translate the lat-lon to a drawing point

var dwgPt = TranslateGeoPoint(db, Point, false);

return dwgPt;
}

public Point2d Point2FromLatLon(Point3d Point)

{
var doc = [Link];
var db = [Link];

// Translate the lat-lon to a drawing point

var dwgPt = TranslateGeoPoint(db, Point, false);

Point2d p2 = new Point2d(dwgPt.X, dwgPt.Y);

return p2;
}
public string getBetween(string Data, string St, string En)
{
int Start, End;
if ([Link](St) && [Link](En))
{
Start = [Link](St, 0) + [Link];
End = [Link](En, Start);
return [Link](Start, End - Start);
}
else
{
return "";
}
}

public void InsertGeoRef(Point3d PC)

{

var doc = [Link];

if (doc == null)

return;

var ed = [Link];

var db = [Link];

var msId = [Link](db);

bool hasGeoData = false;

try
{
var gdId = [Link];
hasGeoData = true;
}
catch { }

if (hasGeoData)
{
[Link]("\nDrawing already has geo-location data!");

return;
}

var data = new GeoLocationData();

[Link] = msId;

[Link]();

[Link] = "WORLD-MERCATOR";

[Link] = [Link];
 var wcsPt = [Link](PC);

[Link] = wcsPt;

[Link] = PC;

[Link]("_.GEOMAP", "_AERIAL");
}

public class BClass

{
CTransaction CT = new CTransaction();

public double BulgeFromCurve(Curve cv, bool clockwise)

{
double bulge = 0.0;
Arc a = cv as Arc;
if (a != null)
{
double newStart;

if ([Link] > [Link])

{
newStart = [Link] - 8 * [Link](1);
}
else
{
newStart = [Link];
}

bulge = [Link](([Link] - newStart) / 4);

if (clockwise)
{
bulge = -bulge;
}
}

return bulge;

}
public Point2d ArcCentroid(Point2d start, Point2d end, Point2d cen, double
tmpArea)
{
double chord = [Link](end);
double angle = (end - start).Angle;
return Polar2d(cen, angle - ([Link] / 2.0), (chord * chord * chord) /
(12.0 * tmpArea));
}

public double ArcAlgebricArea(double rad, double ang)

{
return rad * rad * (ang - [Link](ang)) / 2.0;
}
 public Point2d Polar2d(Point2d org, double angle, double distance)
{
return org + new Vector2d(distance * [Link](angle), distance *
[Link](angle));
}
public double[] GetArcGeom(Polyline pl, double bulge, int index1, int
index2)
{
CircularArc2d arc = (pl.GetArcSegment2dAt(index1));
double arcRadius = [Link];
Point2d arcCenter = [Link];
double arcAngle = 4.0 * [Link](bulge);
double tmpArea = ArcAlgebricArea(arcRadius, arcAngle);
Point2d tmpPoint = ArcCentroid(pl.GetPoint2dAt(index1),
pl.GetPoint2dAt(index2), arcCenter, tmpArea);
return new double[3] { tmpArea, tmpPoint.X, tmpPoint.Y };
}

public Point2d TriangleCentroid(Point2d p0, Point2d p1, Point2d p2)

{
return (p0 + [Link]() + [Link]()) / 3.0;
}

public double TriangleAlgebricArea(Point2d p0, Point2d p1, Point2d p2)

{
return (((p1.X - p0.X) * (p2.Y - p0.Y)) - ((p2.X - p0.X) * (p1.Y -
p0.Y))) / 2.0;
}
public Point3d GetCentroid(Polyline pl)
{
Point2d p0 = pl.GetPoint2dAt(0);
Point2d cen = new Point2d(0.0, 0.0);
double area = 0.0;
int last = [Link] - 1;
double tmpArea;
Point2d tmpPoint;

if ([Link](0) == [Link])
{
double[] datas = GetArcGeom(pl, [Link](0), 0, 1);
area = datas[0];
cen = new Point2d(datas[1], datas[2]) * datas[0];
}
for (int i = 1; i < last; i++)
{
tmpArea = TriangleAlgebricArea(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
tmpPoint = TriangleCentroid(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
cen += (tmpPoint * tmpArea).GetAsVector();
area += tmpArea;
if ([Link](i) == [Link])
{
double[] datas = GetArcGeom(pl, [Link](i), i, i + 1);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
}
}
if ([Link](last) == [Link])
 {
double[] datas = GetArcGeom(pl, [Link](last), last, 0);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
}
cen = [Link](area);
Point3d result = new Point3d(cen.X, cen.Y, [Link]);
return [Link]([Link]([Link]));
}
}

public class CTransaction

{
public Editor editor;
public [Link] document;
public Database database;
public BlockTable blockTable;
public LayerTable layerTable;
public Transaction transaction;
public BlockTableRecord blockTableRecordMe;
public BlockTableRecord blockTableRecordPe;
public DocumentLock documentloc;

public void Start_Trans()

{
document = [Link];

documentloc = [Link]();

database = [Link];

transaction = [Link]();

blockTable = [Link]([Link],
[Link]) as BlockTable;

layerTable = [Link]([Link],
[Link]) as LayerTable;

blockTableRecordMe =
[Link](blockTable[[Link]], [Link])
as BlockTableRecord;

blockTableRecordPe =
[Link](blockTable[[Link]], [Link])
as BlockTableRecord;

editor = [Link];
}

public Point3dCollection Buffer(Polyline rute, double dist)

{
Point3dCollection buffer = new Point3dCollection();
List<Polyline> pllist = new List<Polyline>();
if (rute != null)
{

if (dist > 0)
{
 DBObjectCollection PloffSet1 = [Link](dist);
[Link]();
DBObjectCollection PloffSet2 = [Link](dist);
[Link]();
Polyline pl1buffer = new Polyline();
Polyline pl2buffer = new Polyline();
foreach (Polyline item in PloffSet1) pl1buffer = item;
foreach (Polyline item in PloffSet2) pl2buffer = item;
//Line ln = new Line([Link], [Link]);
//[Link](ln);
//[Link](pl2buffer);
//[Link] = true;
//REVISAR ESTO
//[Link]();

[Link](pl1buffer);

[Link](pl2buffer);
}
else
{
[Link](rute);
}
foreach (Polyline PlB in pllist)
{
for (int i = 0; i < [Link]; i++)
{
[Link](PlB.GetPoint3dAt(i));
if (PlB.GetPoint3dAt(i) !=
PlB.GetPoint3dAt([Link] - 1))
{
if ([Link](i).ToString() == "Arc")
{
for (double j =
[Link](PlB.GetPoint3dAt(i)) + 1; j <
[Link](PlB.GetPoint3dAt(i + 1)); j++)
{
if ())
{
[Link]([Link](j));
}

}
}
}
}
if ([Link])
{
if ([Link]([Link] - 1).ToString()
== "Arc")
{
for (double j =
[Link](PlB.GetPoint3dAt([Link] - 1)) + 1; j < [Link];
j++)
{
[Link]([Link](j));
}
 }
[Link]([Link]);
}
}

}
return buffer;

public Point3dCollection Buffer(Polyline rute, double dist, bool Draw)

{
Point3dCollection LBuffer = Buffer(rute, dist);
if (Draw)
{
Polyline pl = new Polyline();
foreach (Point3d item in LBuffer)
{
[Link]([Link], item.Convert2d(new
Plane()), 0, 0, 0);

}
Insert(pl, true);
}

return LBuffer;
}

public void End_Trans()

{
[Link]();
[Link]();
[Link]();
}

public void Insert(Line OB, bool M)

{
if (M)
[Link](OB);
else
[Link](OB);

[Link](OB, true);
}

public void Hyper(Entity ent, string description, string name, string

sublocation)
{
HyperLinkCollection linkCollection = [Link];
HyperLink hyperLink = new HyperLink();
[Link] = description;
[Link] = name;
[Link] = sublocation;
[Link](hyperLink);
}

public void Insert(Polyline OB, bool M)

{
if (M)
 [Link](OB);
else
[Link](OB);

[Link](OB, true);
}

public void Insert(BlockReference OB)

{
[Link](OB);
[Link](OB, true);
}

public void Insert(Point3d Location, String Block_Name)

{
if(Verify_Exist_Block(Block_Name))
{
BlockReference Br = new BlockReference(Location,
blockTable[Block_Name]);

[Link](Br);
[Link](Br, true);
}
else
{
[Link]("Error When Copying Or Inserting Block");
}
}

public void Insert(BlockReference OB, bool M)

{

string name = [Link] ?

((BlockTableRecord)[Link]([Link])).Name :
[Link];

BlockTableRecord blockDef =
blockTable[name].GetObject([Link]) as BlockTableRecord;

if (M)
[Link](OB);
else
[Link](OB);

[Link](OB, true);

DynamicBlockReferencePropertyCollection pc =
[Link];

foreach (ObjectId id2 in blockDef)

{
DBObject obj = [Link]([Link]);

if (obj is AttributeDefinition)
{
AttributeDefinition attDef = obj as AttributeDefinition;

using (AttributeReference attRef = new AttributeReference())

{
 [Link](attDef, [Link]);

[Link] = true;

[Link](attRef);
[Link](attRef, true);
}
}
}
}

public void Insert(Circle OB, bool M)

{
if (M)
[Link](OB);
else
[Link](OB);

[Link](OB, true);
}

public void Insert(MText OB, bool M)

{
[Link] = [Link];

if (M)
[Link](OB);
else
[Link](OB);

[Link](OB, true);
}

public void Insert(Viewport OB, bool M)

{
if (M)
[Link](OB);
else
[Link](OB);

[Link](OB, true);
}

public void Insert(Entity OB, bool M)

{
if (M)
[Link](OB);
else
[Link](OB);

[Link](OB, true);

if (OB is BlockReference)
{
BlockReference blockReference = (BlockReference)OB;

string name = [Link] ?

((BlockTableRecord)[Link]([Link]
d)).Name : [Link];

BlockTableRecord blockDef =
blockTable[name].GetObject([Link]) as BlockTableRecord;

foreach (ObjectId id2 in blockDef)

{
DBObject obj = [Link]([Link]);

AttributeDefinition attDef = obj as AttributeDefinition;

if ((attDef != null))
{

using (AttributeReference attRef = new

AttributeReference())
{
[Link](attDef,
[Link]);

[Link] = "";
[Link] = true;

[Link](attRef);
[Link](attRef, true);
}
}
}
}

public Entity Get(string Dialog, CTransaction Trans, string Typee)

{
Entity En = null;

PromptSelectionOptions promptPointOptions = new

PromptSelectionOptions();
[Link] = (Dialog);
PromptSelectionResult selectLinesFollow =
[Link](promptPointOptions);
if ([Link] == [Link])
{
foreach (ObjectId Obj in [Link]())
{
DBObject entity = [Link](Obj,
[Link]);
if ([Link]().Name == Typee)
{
En = entity as Polyline;
}
else
{
[Link]([Link]().Name);
 }
}
}

return En;
}

public void End_Trans(bool regen, bool dispose)

{
if (regen) [Link]();
[Link]();
if (dispose) [Link]();
}

public bool Verify_Exist_Block(string Block_Name)

{
bool Find = false;

// Check each block in the block table

foreach (ObjectId BlockTableRecord_Id in blockTable)
{
BlockTableRecord Blocktablerecord =
(BlockTableRecord)[Link](BlockTableRecord_Id, [Link],
false);

// Only add named & non-layout blocks to the copy list

if (![Link] && ![Link] &&
[Link] == Block_Name)
Find = true;
}

if(!Find)
{
if (Copy_Block(Block_Name))
{
return true;
}
else
{
return false;
}
}
else
{
return true;
}
}

public bool Verify_Exist_Layer(string Layer_Name)

{
CLayer CLAYERS = new CLayer();

bool Find = false;

ArrayList Layers = [Link]();

foreach(string S in Layers)
{
if (S == Layer_Name)
 {
Find = true;

}
}

if (!Find)
{
if (Copy_Layer(Layer_Name))
{
return true;
}
else
{
return false;
}
}
else
{
return true;
}
}

public bool Copy_Block(string Block_Name)

{
CDatabase Db = new CDatabase
{
DataSource = @"C:\GenXCTool\DBS\[Link]"
};

[Link] Dt = [Link]("Select * From OneDrive");

string Dir = [Link][0][0].ToString();

bool RETURN = false;

DocumentCollection Document_Collect = [Link];

Editor EDITOR = Document_Collect.[Link];

Database Des_DB = Document_Collect.[Link];

Database Sor_Db = new Database(false, true);

try
{

// Get name of DWG from which to copy blocks

// sourceFileName = [Link]("\nEnter the name of the source

drawing: ");

//sourceFileName = @"Z:\Desktop\Template [Link]";

// Read the DWG into a side database

Sor_Db.ReadDwgFile(Dir + "/Autocad/Blocks/" + Block_Name + ".dwg",
[Link], true, "");
 //[Link](Dir + "/Autocad/Blocks/" + Block_Name + ".dwg");

// Create a variable to store the list of block identifiers

ObjectIdCollection Blocks_Id = new ObjectIdCollection();

[Link]
Sor_Trans_Manager = Sor_Db.TransactionManager;

using (Transaction Sor_Trans =

Sor_Trans_Manager.StartTransaction())
{

// Open the block table

BlockTable Block_Table =
(BlockTable)Sor_Trans.GetObject(Sor_Db.BlockTableId, [Link], false);

// Check each block in the block table

foreach (ObjectId Block_Table_Id in Block_Table)

{

BlockTableRecord Block_Table_Record =
(BlockTableRecord)Sor_Trans.GetObject(Block_Table_Id, [Link], false);

// Only add named & non-layout blocks to the copy list

if (!Block_Table_Record.IsAnonymous && !
Block_Table_Record.IsLayout && Block_Table_Record.Name == Block_Name)
Blocks_Id.Add(Block_Table_Id);

Block_Table_Record.Dispose();

// Copy blocks from source to destination database

IdMapping Mapping = new IdMapping();

Sor_Db.WblockCloneObjects(Blocks_Id, Des_DB.BlockTableId, Mapping,

[Link], false);

[Link]("\nCopied " + Blocks_Id.[Link]() + "

block definitions to the current drawing.");

RETURN = true;
}
catch ([Link] ex)
{
[Link]("\nError during copy: " + [Link]);
RETURN = false;
}

Sor_Db.Dispose();
 return RETURN;
}

public bool Copy_Layer(string Layer_Name)

{
bool RETURN = false;

DocumentCollection Document_Collect = [Link];

Editor EDITOR = Document_Collect.[Link];

var curDb = [Link];

string dwgPath = @"Z:\Desktop\Template [Link]";
using (var db = new Database(false, true))
{
[Link](dwgPath, [Link], true,
null);
using (var tr = [Link]())
{
var layerTable = (LayerTable)[Link]([Link],
[Link]);
if ()
{
[Link]("\nError during copy: " + Layer_Name);

return false;
}
else
{
var ids = new ObjectIdCollection();
[Link](layerTable[Layer_Name]);
var mapping = new IdMapping();
[Link](ids, [Link], mapping,
[Link], false);

[Link]("\nCopied " + Layer_Name + " Layer

definitions to the current drawing.");

return true;
}
}
}

return RETURN;
}
}

public class CCentroide

{
#region Geometric Center of Polyline
public double BulgeFromCurve(Curve cv, bool clockwise)
{
double bulge = 0.0;
Arc a = cv as Arc;
if (a != null)
{
double newStart;
// The start angle is usually greater than the end,
 // as arcs are all counter-clockwise.

// (If it isn't it's because the arc crosses the

// 0-degree line, and we can subtract 2PI from the

// start angle.)
if ([Link] > [Link])
{
newStart = [Link] - 8 * [Link](1);
}
else
{
newStart = [Link];
}
// Bulge is defined as the tan of

// one fourth of the included angle

bulge = [Link](([Link] - newStart) / 4);

// If the curve is clockwise, we negate the bulge
if (clockwise)
{
bulge = -bulge;
}
}

return bulge;

public Point3d GetCentroid(Polyline pl)

{
Point2d p0 = pl.GetPoint2dAt(0);
Point2d cen = new Point2d(0.0, 0.0);
double area = 0.0;
double bulge = [Link](0);
int last = [Link] - 1;
double tmpArea;
Point2d tmpPoint;

if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, 0, 1);
area = datas[0];
cen = new Point2d(datas[1], datas[2]) * datas[0];
}
for (int i = 1; i < last; i++)
{
tmpArea = TriangleAlgebricArea(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
tmpPoint = TriangleCentroid(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
cen += (tmpPoint * tmpArea).GetAsVector();
area += tmpArea;
bulge = [Link](i);
if (bulge != 0.0)
{
 double[] datas = GetArcGeom(pl, bulge, i, i + 1);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
}
}
bulge = [Link](last);
if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, last, 0);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
}
cen = [Link](area);
Point3d result = new Point3d(cen.X, cen.Y, [Link]);
return [Link]([Link]([Link]));
}

public Point2d GetCentroid_2d(Polyline pl)

{
Point2d p0 = pl.GetPoint2dAt(0);
Point2d cen = new Point2d(0.0, 0.0);
double area = 0.0;
double bulge = [Link](0);
int last = [Link] - 1;
double tmpArea;
Point2d tmpPoint;

if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, 0, 1);
area = datas[0];
cen = new Point2d(datas[1], datas[2]) * datas[0];
}
for (int i = 1; i < last; i++)
{
tmpArea = TriangleAlgebricArea(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
tmpPoint = TriangleCentroid(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
cen += (tmpPoint * tmpArea).GetAsVector();
area += tmpArea;
bulge = [Link](i);
if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, i, i + 1);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
}
}
bulge = [Link](last);
if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, last, 0);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
}
cen = [Link](area);
Point3d result = new Point3d(cen.X, cen.Y, [Link]);
 result = [Link]([Link]([Link]));
return new Point2d(result.X, result.Y);
}

private static double[] GetArcGeom(Polyline pl, double bulge, int index1,

int index2)
{
CircularArc2d arc = (pl.GetArcSegment2dAt(index1));
double arcRadius = [Link];
Point2d arcCenter = [Link];
double arcAngle = 4.0 * [Link](bulge);
double tmpArea = ArcAlgebricArea(arcRadius, arcAngle);
Point2d tmpPoint = ArcCentroid(pl.GetPoint2dAt(index1),
pl.GetPoint2dAt(index2), arcCenter, tmpArea);
return new double[3] { tmpArea, tmpPoint.X, tmpPoint.Y };
}

private static Point2d TriangleCentroid(Point2d p0, Point2d p1, Point2d p2)

{
return (p0 + [Link]() + [Link]()) / 3.0;
}

private static double TriangleAlgebricArea(Point2d p0, Point2d p1, Point2d

p2)
{
return (((p1.X - p0.X) * (p2.Y - p0.Y)) - ((p2.X - p0.X) * (p1.Y -
p0.Y))) / 2.0;
}

private static Point2d ArcCentroid(Point2d start, Point2d end, Point2d cen,

double tmpArea)
{
double chord = [Link](end);
double angle = (end - start).Angle;
return Polar2d(cen, angle - ([Link] / 2.0), (chord * chord * chord) /
(12.0 * tmpArea));
}

private static double ArcAlgebricArea(double rad, double ang)

{
return rad * rad * (ang - [Link](ang)) / 2.0;
}

private static Point2d Polar2d(Point2d org, double angle, double distance)

{
return org + new Vector2d(distance * [Link](angle), distance *
[Link](angle));
}

#endregion
}

public class CPole

{
/* private string pole_tag = " ";
private string pole_owner = " ";
private string material = " ";
private string pole_class = " ";
 private string ground = " ";
private string telco_first_attachment = " ";
private string telco_second_attachment = " ";
private string comcast = " ";
private string catv_second_attachment = " ";
private string streetlight = " ";
private string secondaryneutral = " ";
private string transfer = " ";
private string pole_address_full = " ";

private string proposed_or_existing_1 = " ";

private string bearing_1 = " ";
private string lead_1 = " ";
private string photo = " ";

private int pole_tag_p = 0;

private int pole_owner_p = 0;
private int material_p = 0;
private int pole_class_p = 0;
private int ground_p = 0;
private int telco_first_attachment_p = 0;
private int telco_second_attachment_p = 0;
private int comcast_p = 0;
private int catv_second_attachment_p = 0;
private int streetlight_p = 0;
private int secondaryneutral_p = 0;
private int transfer_p = 0;

private int proposed_or_existing_1_p = 0;

private int bearing_1_p = 0;
private int lead_1_p = 0;
private int photo_p = 0;
private int latitude_p = 0;
private int longitude_p = 0;*/

//public string Pole_Detail(string S, int P)

//{
// try
// {
// string Data = "";
// var reader = new StreamReader(S);
// int lines = 0;

// while (![Link])
// {
// string[] comas;
// string line = [Link]();
// string[] values = [Link](',');

// if (lines == 0)
// for (int c = 0; c < [Link]; c++)
// if (values[c] == "pole_owner")
// pole_owner_p = c;
// else if (values[c] == "material")
// material_p = c;
// else if (values[c] == "pole_class")
// pole_class_p = c;
// else if (values[c] == "ground")
 // ground_p = c;
// else if (values[c] == "telco_first_attachment")
// telco_first_attachment_p = c;
// else if (values[c] == "telco_second_attachment")
// telco_second_attachment_p = c;
// else if (values[c] == "comcast")
// comcast_p = c;
// else if (values[c] == "catv_second_attachment")
// catv_second_attachment_p = c;
// else if (values[c] == "streetlight")
// streetlight_p = c;
// else if (values[c] == "secondaryneutral")
// secondaryneutral_p = c;
// else if (values[c] == "transfer" || values[c] ==
"general_notes")
// transfer_p = c;
// else if (values[c] == "pole_tag")
// pole_tag_p = c;

// if (lines == P && P != 0)
// {
// pole_owner = values[pole_owner_p];

// if (pole_tag_p != 0)
// {
// pole_tag = values[pole_tag_p];
// }

// if (pole_owner != "Cross Messenger")

// {
// if(material_p != 0)
// material = values[material_p];

// if(pole_class_p != 0)
// pole_class = values[pole_class_p];

// if (ground_p != 0)
// ground = values[ground_p];

// if(telco_first_attachment_p != 0)
// telco_first_attachment =
values[telco_first_attachment_p];

// if(telco_second_attachment_p != 0)
// telco_second_attachment =
values[telco_second_attachment_p];

// if(comcast_p != 0)
// comcast = values[comcast_p];

// if(catv_second_attachment_p != 0)
// catv_second_attachment =
values[catv_second_attachment_p];

// if(streetlight_p != 0)
// streetlight = values[streetlight_p];

// if(secondaryneutral_p != 0)
 // secondaryneutral = values[secondaryneutral_p];

// if(transfer_p != 0)
// transfer = values[transfer_p];

// try
// {
// if (pole_tag != " " && pole_tag != "")
// {
// Data += "Pole#: " +
Convert.ToInt32(pole_tag).ToString();
// }
// }
// catch (Exception)
// {
// Data += pole_tag;
// }

// if (pole_owner == "BST Pole")

// Data += "\n" + "TELCO POLE";
// else
// Data += "\n" + pole_owner;

// if (material != "" && material != " ")

// Data += "\n" + material;

// if (pole_class != " " && pole_class != "")

// {
// comas = pole_class.Split('-');
// pole_class = comas[0] + " - " + comas[1];
// Data += "\n" + material;
// Data += "\n" + "CLASS: " + pole_class;
// }

// if (ground != " " && ground != "")

// {
// Data += "\n" + "MGNV: " + ground;
// }

// if (telco_first_attachment != " " &&

telco_first_attachment != "")
// {
// comas = telco_first_attachment.Split('-');
// telco_first_attachment = comas[0] + "' - " +
comas[1] + "\" ";
// Data += "\n" + "TELCO: " +
telco_first_attachment;
// }

// if (telco_second_attachment != " " &&

telco_second_attachment != "")
// {
// comas = telco_second_attachment.Split('-');
// telco_second_attachment = comas[0] + "' - " +
comas[1] + "\" ";
// Data += "\n" + "TELCO: " +
telco_second_attachment;
// }
 // if (comcast != " " && comcast != "")
// {
// comas = [Link]('-');
// comcast = comas[0] + "' - " + comas[1] + "\" ";
// Data += "\n" + "CATV: " + comcast;
// }

// if (catv_second_attachment != " " &&

catv_second_attachment != "")
// {
// comas = catv_second_attachment.Split('-');
// catv_second_attachment = comas[0] + "' - " +
comas[1] + "\" ";
// Data += "\n" + "CATV: " + catv_second_attachment;
// }

// if (streetlight != " " && streetlight != "")

// {
// comas = [Link]('-');
// streetlight = comas[0] + "' - " + comas[1] + "\"
";
// Data += "\n" + "LIGHT: " + streetlight;
// }

// if (secondaryneutral != " " && secondaryneutral !=

"")
// {
// comas = [Link]('-');
// secondaryneutral = comas[0] + "' - " + comas[1] +
"\" ";
// Data += "\n" + "POWER: " + secondaryneutral;
// }

// if ([Link]("Yes") ||
[Link]("Transfer"))
// {
// Data += "\n" + transfer;
// }

// }

// else
// {
// try
// {
// if (pole_tag != " " && pole_tag != "")
// {
// Data += "Pole#: " +
Convert.ToInt32(pole_tag).ToString();
// }
// }
// catch (Exception)
// {
// Data += pole_tag;
// }

// Data += "\n" + pole_owner;

// }

// }
// lines++;
// }
// return [Link]();
// }
// catch (Exception Ex)
// {
// [Link](Ex + "");
// return "Explote";
// }
//}

private string fulcrum_id = " ";

private string fulcrum_parent_id = " ";
private string fulcrum_record_id = " ";
private string version = " ";
private string latitude = " ";
private string longitude = " ";
private string geometry = " ";
private string created_at = " ";
private string updated_at = " ";
private string created_by = " ";
private string updated_by = " ";
private string pole_owner = " ";
private string pole_tag = " ";
private string pole_address_sub_thoroughfare = " ";
private string pole_address_thoroughfare = " ";
private string pole_address_suite = " ";
private string pole_address_locality = " ";
private string pole_address_sub_admin_area = " ";
private string pole_address_admin_area = " ";
private string pole_address_postal_code = " ";
private string pole_address_country = " ";
private string pole_address_full = " ";
private string pole_boc_eop_measurement = " ";
private string pole_class = " ";
private string material = " ";
private string strand_size = " ";
private string guying = " ";
private string joint_use_anchor_1 = " ";
private string proposed_or_existing_1 = " ";
private string anchor_size_1 = " ";
private string down_guy_wire_size_1 = " ";
private string lead_1 = " ";
private string guy_quantity_1 = " ";
private string guy_hoa_1 = " ";
private string pull_1 = " ";
private string bearing_1 = " ";
private string number_of_eyes_1 = " ";
private string joint_use_anchor_2 = " ";
private string proposed_or_existing_2 = " ";
private string anchor_size_2 = " ";
private string down_guy_wire_size_2 = " ";
private string lead_2 = " ";
private string guy_quantity_2 = " ";
private string guy_hoa_2 = " ";
private string pull_2 = " ";
private string bearing_2 = " ";
private string number_of_eyes_2 = " ";
private string joint_use_anchor_3 = " ";
private string proposed_or_existing_3 = " ";
private string anchor_size_3 = " ";
private string down_guy_wire_size_3 = " ";
private string lead_3 = " ";
private string guy_quantity_3 = " ";
private string guy_hoa_3 = " ";
private string pull_3 = " ";
private string bearing_3 = " ";
private string number_of_eyes_3 = " ";
private string joint_use_anchor_4 = " ";
private string proposed_or_existing_4 = " ";
private string anchor_size_4 = " ";
private string down_guy_wire_size_4 = " ";
private string lead_4 = " ";
private string guy_quantity_4 = " ";
private string guy_hoa_4 = " ";
private string pull_4 = " ";
private string bearing_4 = " ";
private string number_of_eyes_4 = " ";
private string telco_first_attachment = " ";
private string telco_second_attachment = " ";
private string roadside_attachment = " ";
private string catv_first_attachment = " ";
private string catv_second_attachment = " ";
private string roadside_attachment_2 = " ";
private string provider_1 = " ";
private string hoa_1 = " ";
private string provider_2 = " ";
private string hoa_2 = " ";
private string provider_3 = " ";
private string hoa_3 = " ";
private string provider_4 = " ";
private string hoa_4 = " ";
private string provider_5 = " ";
private string hoa_5 = " ";
private string secondaryneutral = " ";
private string streetlight = " ";
private string transformer = " ";
private string ground = " ";
private string general_notes = " ";
private string damage_notes = " ";
private string photo = " ";
private string photo_caption = " ";
private string photo_url = " ";

private int fulcrum_id_p = 0;

private int fulcrum_parent_id_p = 0;
private int fulcrum_record_id_p = 0;
private int version_p = 0;
private int latitude_p = 0;
private int longitude_p = 0;
private int geometry_p = 0;
private int created_at_p = 0;
private int updated_at_p = 0;
private int created_by_p = 0;
private int updated_by_p = 0;
private int pole_owner_p = 0;
private int pole_tag_p = 0;
private int pole_address_sub_thoroughfare_p = 0;
private int pole_address_thoroughfare_p = 0;
private int pole_address_suite_p = 0;
private int pole_address_locality_p = 0;
private int pole_address_sub_admin_area_p = 0;
private int pole_address_admin_area_p = 0;
private int pole_address_postal_code_p = 0;
private int pole_address_country_p = 0;
private int pole_address_full_p = 0;
private int pole_boc_eop_measurement_p = 0;
private int pole_class_p = 0;
private int material_p = 0;
private int strand_size_p = 0;
private int guying_p = 0;
private int joint_use_anchor_1_p = 0;
private int proposed_or_existing_1_p = 0;
private int anchor_size_1_p = 0;
private int down_guy_wire_size_1_p = 0;
private int lead_1_p = 0;
private int guy_quantity_1_p = 0;
private int guy_hoa_1_p = 0;
private int pull_1_p = 0;
private int bearing_1_p = 0;
private int number_of_eyes_1_p = 0;
private int joint_use_anchor_2_p = 0;
private int proposed_or_existing_2_p = 0;
private int anchor_size_2_p = 0;
private int down_guy_wire_size_2_p = 0;
private int lead_2_p = 0;
private int guy_quantity_2_p = 0;
private int guy_hoa_2_p = 0;
private int pull_2_p = 0;
private int bearing_2_p = 0;
private int number_of_eyes_2_p = 0;
private int joint_use_anchor_3_p = 0;
private int proposed_or_existing_3_p = 0;
private int anchor_size_3_p = 0;
private int down_guy_wire_size_3_p = 0;
private int lead_3_p = 0;
private int guy_quantity_3_p = 0;
private int guy_hoa_3_p = 0;
private int pull_3_p = 0;
private int bearing_3_p = 0;
private int number_of_eyes_3_p = 0;
private int joint_use_anchor_4_p = 0;
private int proposed_or_existing_4_p = 0;
private int anchor_size_4_p = 0;
private int down_guy_wire_size_4_p = 0;
private int lead_4_p = 0;
private int guy_quantity_4_p = 0;
private int guy_hoa_4_p = 0;
private int pull_4_p = 0;
private int bearing_4_p = 0;
private int number_of_eyes_4_p = 0;
private int telco_first_attachment_p = 0;
private int telco_second_attachment_p = 0;
private int roadside_attachment_p = 0;
private int catv_first_attachment_p = 0;
private int catv_second_attachment_p = 0;
private int roadside_attachment_2_p = 0;
private int provider_1_p = 0;
private int hoa_1_p = 0;
private int provider_2_p = 0;
private int hoa_2_p = 0;
private int provider_3_p = 0;
private int hoa_3_p = 0;
private int provider_4_p = 0;
private int hoa_4_p = 0;
private int provider_5_p = 0;
private int hoa_5_p = 0;
private int secondaryneutral_p = 0;
private int streetlight_p = 0;
private int transformer_p = 0;
private int ground_p = 0;
private int general_notes_p = 0;
private int damage_notes_p = 0;
private int photo_p = 0;
private int photo_caption_p = 0;
private int photo_url_p = 0;

public string Pole_Detail(string S, int P)

{
try
{
string Data = "";
var reader = new StreamReader(S);
int lines = 0;

while (![Link])
{
string[] comas;
string line = [Link]();
string[] values = [Link](',');

if (lines == 0)
for (int c = 0; c < [Link]; c++)
if (values[c] == "fulcrum_id")
fulcrum_id_p = c;
else if (values[c] == "fulcrum_parent_id")
fulcrum_parent_id_p = c;
else if (values[c] == "fulcrum_record_id")
fulcrum_record_id_p = c;
else if (values[c] == "version")
version_p = c;
else if (values[c] == "latitude")
latitude_p = c;
else if (values[c] == "longitude")
longitude_p = c;
else if (values[c] == "geometry")
geometry_p = c;
else if (values[c] == "created_at")
created_at_p = c;
else if (values[c] == "updated_at")
 updated_at_p = c;
else if (values[c] == "created_by")
created_by_p = c;
else if (values[c] == "updated_by")
updated_by_p = c;
else if (values[c] == "pole_owner")
pole_owner_p = c;
else if (values[c] == "pole_tag")
pole_tag_p = c;
else if (values[c] == "pole_address_sub_thoroughfare")
pole_address_sub_thoroughfare_p = c;
else if (values[c] == "pole_address_thoroughfare")
pole_address_thoroughfare_p = c;
else if (values[c] == "pole_address_suite")
pole_address_suite_p = c;
else if (values[c] == "pole_address_locality")
pole_address_locality_p = c;
else if (values[c] == "pole_address_sub_admin_area")
pole_address_sub_admin_area_p = c;
else if (values[c] == "pole_address_admin_area")
pole_address_admin_area_p = c;
else if (values[c] == "pole_address_postal_code")
pole_address_postal_code_p = c;
else if (values[c] == "pole_address_country")
pole_address_country_p = c;
else if (values[c] == "pole_address_full")
pole_address_full_p = c;
else if (values[c] == "pole_boc_eop_measurement")
pole_boc_eop_measurement_p = c;
else if (values[c] == "pole_class")
pole_class_p = c;
else if (values[c] == "material")
material_p = c;
else if (values[c] == "strand_size")
strand_size_p = c;
else if (values[c] == "guying")
guying_p = c;
else if (values[c] == "joint_use_anchor_1")
joint_use_anchor_1_p = c;
else if (values[c] == "proposed_or_existing_1")
proposed_or_existing_1_p = c;
else if (values[c] == "anchor_size_1")
anchor_size_1_p = c;
else if (values[c] == "down_guy_wire_size_1")
down_guy_wire_size_1_p = c;
else if (values[c] == "lead_1")
lead_1_p = c;
else if (values[c] == "guy_quantity_1")
guy_quantity_1_p = c;
else if (values[c] == "guy_hoa_1")
guy_hoa_1_p = c;
else if (values[c] == "pull_1")
pull_1_p = c;
else if (values[c] == "bearing_1")
bearing_1_p = c;
else if (values[c] == "number_of_eyes_1")
number_of_eyes_1_p = c;
else if (values[c] == "joint_use_anchor_2")
joint_use_anchor_2_p = c;
else if (values[c] == "proposed_or_existing_2")
proposed_or_existing_2_p = c;
else if (values[c] == "anchor_size_2")
anchor_size_2_p = c;
else if (values[c] == "down_guy_wire_size_2")
down_guy_wire_size_2_p = c;
else if (values[c] == "lead_2")
lead_2_p = c;
else if (values[c] == "guy_quantity_2")
guy_quantity_2_p = c;
else if (values[c] == "guy_hoa_2")
guy_hoa_2_p = c;
else if (values[c] == "pull_2")
pull_2_p = c;
else if (values[c] == "bearing_2")
bearing_2_p = c;
else if (values[c] == "number_of_eyes_2")
number_of_eyes_2_p = c;
else if (values[c] == "joint_use_anchor_3")
joint_use_anchor_3_p = c;
else if (values[c] == "proposed_or_existing_3")
proposed_or_existing_3_p = c;
else if (values[c] == "anchor_size_3")
anchor_size_3_p = c;
else if (values[c] == "down_guy_wire_size_3")
down_guy_wire_size_3_p = c;
else if (values[c] == "lead_3")
lead_3_p = c;
else if (values[c] == "guy_quantity_3")
guy_quantity_3_p = c;
else if (values[c] == "guy_hoa_3")
guy_hoa_3_p = c;
else if (values[c] == "pull_3")
pull_3_p = c;
else if (values[c] == "bearing_3")
bearing_3_p = c;
else if (values[c] == "number_of_eyes_3")
number_of_eyes_3_p = c;
else if (values[c] == "joint_use_anchor_4")
joint_use_anchor_4_p = c;
else if (values[c] == "proposed_or_existing_4")
proposed_or_existing_4_p = c;
else if (values[c] == "anchor_size_4")
anchor_size_4_p = c;
else if (values[c] == "down_guy_wire_size_4")
down_guy_wire_size_4_p = c;
else if (values[c] == "lead_4")
lead_4_p = c;
else if (values[c] == "guy_quantity_4")
guy_quantity_4_p = c;
else if (values[c] == "guy_hoa_4")
guy_hoa_4_p = c;
else if (values[c] == "pull_4")
pull_4_p = c;
else if (values[c] == "bearing_4")
bearing_4_p = c;
else if (values[c] == "number_of_eyes_4")
number_of_eyes_4_p = c;
else if (values[c] == "telco_first_attachment")
 telco_first_attachment_p = c;
else if (values[c] == "telco_second_attachment")
telco_second_attachment_p = c;
else if (values[c] == "roadside_attachment")
roadside_attachment_p = c;
else if (values[c] == "catv_first_attachment")
catv_first_attachment_p = c;
else if (values[c] == "catv_second_attachment")
catv_second_attachment_p = c;
else if (values[c] == "roadside_attachment_2")
roadside_attachment_2_p = c;
else if (values[c] == "provider_1")
provider_1_p = c;
else if (values[c] == "hoa_1")
hoa_1_p = c;
else if (values[c] == "provider_2")
provider_2_p = c;
else if (values[c] == "hoa_2")
hoa_2_p = c;
else if (values[c] == "provider_3")
provider_3_p = c;
else if (values[c] == "hoa_3")
hoa_3_p = c;
else if (values[c] == "provider_4")
provider_4_p = c;
else if (values[c] == "hoa_4")
hoa_4_p = c;
else if (values[c] == "provider_5")
provider_5_p = c;
else if (values[c] == "hoa_5")
hoa_5_p = c;
else if (values[c] == "secondaryneutral")
secondaryneutral_p = c;
else if (values[c] == "streetlight")
streetlight_p = c;
else if (values[c] == "transformer")
transformer_p = c;
else if (values[c] == "ground")
ground_p = c;
else if (values[c] == "general_notes")
general_notes_p = c;
else if (values[c] == "damage_notes")
damage_notes_p = c;
else if (values[c] == "photo")
photo_p = c;
else if (values[c] == "photo_caption")
photo_caption_p = c;
else if (values[c] == "photo_url")
photo_url_p = c;

if (fulcrum_id_p != 0)
fulcrum_id = values[fulcrum_id_p];
if (fulcrum_parent_id_p != 0)
fulcrum_parent_id = values[fulcrum_parent_id_p];
if (fulcrum_record_id_p != 0)
fulcrum_record_id = values[fulcrum_record_id_p];
if (version_p != 0)
version = values[version_p];
if (latitude_p != 0)
 latitude = values[latitude_p];
if (longitude_p != 0)
longitude = values[longitude_p];
if (geometry_p != 0)
geometry = values[geometry_p];
if (created_at_p != 0)
created_at = values[created_at_p];
if (updated_at_p != 0)
updated_at = values[updated_at_p];
if (created_by_p != 0)
created_by = values[created_by_p];
if (updated_by_p != 0)
updated_by = values[updated_by_p];
if (pole_owner_p != 0)
pole_owner = values[pole_owner_p];
if (pole_tag_p != 0)
pole_tag = values[pole_tag_p];
if (pole_address_sub_thoroughfare_p != 0)
pole_address_sub_thoroughfare =
values[pole_address_sub_thoroughfare_p];
if (pole_address_thoroughfare_p != 0)
pole_address_thoroughfare =
values[pole_address_thoroughfare_p];
if (pole_address_suite_p != 0)
pole_address_suite = values[pole_address_suite_p];
if (pole_address_locality_p != 0)
pole_address_locality = values[pole_address_locality_p];
if (pole_address_sub_admin_area_p != 0)
pole_address_sub_admin_area =
values[pole_address_sub_admin_area_p];
if (pole_address_admin_area_p != 0)
pole_address_admin_area =
values[pole_address_admin_area_p];
if (pole_address_postal_code_p != 0)
pole_address_postal_code =
values[pole_address_postal_code_p];
if (pole_address_country_p != 0)
pole_address_country = values[pole_address_country_p];
if (pole_address_full_p != 0)
pole_address_full = values[pole_address_full_p];
if (pole_boc_eop_measurement_p != 0)
pole_boc_eop_measurement =
values[pole_boc_eop_measurement_p];
if (pole_class_p != 0)
pole_class = values[pole_class_p];
if (material_p != 0)
material = values[material_p];
if (strand_size_p != 0)
strand_size = values[strand_size_p];
if (guying_p != 0)
guying = values[guying_p];
if (joint_use_anchor_1_p != 0)
joint_use_anchor_1 = values[joint_use_anchor_1_p];
if (proposed_or_existing_1_p != 0)
proposed_or_existing_1 = values[proposed_or_existing_1_p];
if (anchor_size_1_p != 0)
anchor_size_1 = values[anchor_size_1_p];
if (down_guy_wire_size_1_p != 0)
down_guy_wire_size_1 = values[down_guy_wire_size_1_p];
if (lead_1_p != 0)
lead_1 = values[lead_1_p];
if (guy_quantity_1_p != 0)
guy_quantity_1 = values[guy_quantity_1_p];
if (guy_hoa_1_p != 0)
guy_hoa_1 = values[guy_hoa_1_p];
if (pull_1_p != 0)
pull_1 = values[pull_1_p];
if (bearing_1_p != 0)
bearing_1 = values[bearing_1_p];
if (number_of_eyes_1_p != 0)
number_of_eyes_1 = values[number_of_eyes_1_p];
if (joint_use_anchor_2_p != 0)
joint_use_anchor_2 = values[joint_use_anchor_2_p];
if (proposed_or_existing_2_p != 0)
proposed_or_existing_2 = values[proposed_or_existing_2_p];
if (anchor_size_2_p != 0)
anchor_size_2 = values[anchor_size_2_p];
if (down_guy_wire_size_2_p != 0)
down_guy_wire_size_2 = values[down_guy_wire_size_2_p];
if (lead_2_p != 0)
lead_2 = values[lead_2_p];
if (guy_quantity_2_p != 0)
guy_quantity_2 = values[guy_quantity_2_p];
if (guy_hoa_2_p != 0)
guy_hoa_2 = values[guy_hoa_2_p];
if (pull_2_p != 0)
pull_2 = values[pull_2_p];
if (bearing_2_p != 0)
bearing_2 = values[bearing_2_p];
if (number_of_eyes_2_p != 0)
number_of_eyes_2 = values[number_of_eyes_2_p];
if (joint_use_anchor_3_p != 0)
joint_use_anchor_3 = values[joint_use_anchor_3_p];
if (proposed_or_existing_3_p != 0)
proposed_or_existing_3 = values[proposed_or_existing_3_p];
if (anchor_size_3_p != 0)
anchor_size_3 = values[anchor_size_3_p];
if (down_guy_wire_size_3_p != 0)
down_guy_wire_size_3 = values[down_guy_wire_size_3_p];
if (lead_3_p != 0)
lead_3 = values[lead_3_p];
if (guy_quantity_3_p != 0)
guy_quantity_3 = values[guy_quantity_3_p];
if (guy_hoa_3_p != 0)
guy_hoa_3 = values[guy_hoa_3_p];
if (pull_3_p != 0)
pull_3 = values[pull_3_p];
if (bearing_3_p != 0)
bearing_3 = values[bearing_3_p];
if (number_of_eyes_3_p != 0)
number_of_eyes_3 = values[number_of_eyes_3_p];
if (joint_use_anchor_4_p != 0)
joint_use_anchor_4 = values[joint_use_anchor_4_p];
if (proposed_or_existing_4_p != 0)
proposed_or_existing_4 = values[proposed_or_existing_4_p];
if (anchor_size_4_p != 0)
anchor_size_4 = values[anchor_size_4_p];
if (down_guy_wire_size_4_p != 0)
 down_guy_wire_size_4 = values[down_guy_wire_size_4_p];
if (lead_4_p != 0)
lead_4 = values[lead_4_p];
if (guy_quantity_4_p != 0)
guy_quantity_4 = values[guy_quantity_4_p];
if (guy_hoa_4_p != 0)
guy_hoa_4 = values[guy_hoa_4_p];
if (pull_4_p != 0)
pull_4 = values[pull_4_p];
if (bearing_4_p != 0)
bearing_4 = values[bearing_4_p];
if (number_of_eyes_4_p != 0)
number_of_eyes_4 = values[number_of_eyes_4_p];
if (telco_first_attachment_p != 0)
telco_first_attachment = values[telco_first_attachment_p];
if (telco_second_attachment_p != 0)
telco_second_attachment =
values[telco_second_attachment_p];
if (roadside_attachment_p != 0)
roadside_attachment = values[roadside_attachment_p];
if (catv_first_attachment_p != 0)
catv_first_attachment = values[catv_first_attachment_p];
if (catv_second_attachment_p != 0)
catv_second_attachment = values[catv_second_attachment_p];
if (roadside_attachment_2_p != 0)
roadside_attachment_2 = values[roadside_attachment_2_p];
if (provider_1_p != 0)
provider_1 = values[provider_1_p];
if (hoa_1_p != 0)
hoa_1 = values[hoa_1_p];
if (provider_2_p != 0)
provider_2 = values[provider_2_p];
if (hoa_2_p != 0)
hoa_2 = values[hoa_2_p];
if (provider_3_p != 0)
provider_3 = values[provider_3_p];
if (hoa_3_p != 0)
hoa_3 = values[hoa_3_p];
if (provider_4_p != 0)
provider_4 = values[provider_4_p];
if (hoa_4_p != 0)
hoa_4 = values[hoa_4_p];
if (provider_5_p != 0)
provider_5 = values[provider_5_p];
if (hoa_5_p != 0)
hoa_5 = values[hoa_5_p];
if (secondaryneutral_p != 0)
secondaryneutral = values[secondaryneutral_p];
if (streetlight_p != 0)
streetlight = values[streetlight_p];
if (transformer_p != 0)
transformer = values[transformer_p];
if (ground_p != 0)
ground = values[ground_p];
if (general_notes_p != 0)
general_notes = values[general_notes_p];
if (damage_notes_p != 0)
damage_notes = values[damage_notes_p];
if (photo_p != 0)
 photo = values[photo_p];
if (photo_caption_p != 0)
photo_caption = values[photo_caption_p];
if (photo_url_p != 0)
photo_url = values[photo_url_p];

if (lines == P && P != 0)
{
if (pole_owner != " " && pole_owner != "")
{
Data += "pole_owner: " + pole_owner + "\n";
}
if (pole_tag != " " && pole_tag != "")
{
Data += "pole_tag: " + pole_tag + "\n";
}
if (pole_address_full != " " && pole_address_full != "")
{
Data += "pole_address_full: " + pole_address_full + "\
n";
}
if (pole_boc_eop_measurement != " " &&
pole_boc_eop_measurement != "")
{
Data += "pole_boc_eop_measurement: " +
pole_boc_eop_measurement + "\n";
}
if (pole_class != " " && pole_class != "")
{
Data += "pole_class: " + pole_class + "\n";
}
if (material != " " && material != "")
{
Data += "material: " + material + "\n";
}
if (strand_size != " " && strand_size != "")
{
Data += "strand_size: " + strand_size + "\n";
}
if (guying != " " && guying != "")
{
Data += "guying: " + guying + "\n";
}
if (joint_use_anchor_1 != " " && joint_use_anchor_1 != "")
{
Data += "joint_use_anchor_1: " + joint_use_anchor_1 +
"\n";
}
if (proposed_or_existing_1 != " " && proposed_or_existing_1
!= "")
{
Data += "proposed_or_existing_1: " +
proposed_or_existing_1 + "\n";
}
if (anchor_size_1 != " " && anchor_size_1 != "")
{
Data += "anchor_size_1: " + anchor_size_1 + "\n";
}
 if (down_guy_wire_size_1 != " " && down_guy_wire_size_1 !=
"")
{
Data += "down_guy_wire_size_1: " + down_guy_wire_size_1
+ "\n";
}
if (lead_1 != " " && lead_1 != "")
{
Data += "lead_1: " + lead_1 + "\n";
}
if (guy_quantity_1 != " " && guy_quantity_1 != "")
{
Data += "guy_quantity_1: " + guy_quantity_1 + "\n";
}
if (guy_hoa_1 != " " && guy_hoa_1 != "")
{
Data += "guy_hoa_1: " + guy_hoa_1 + "\n";
}
if (pull_1 != " " && pull_1 != "")
{
Data += "pull_1: " + pull_1 + "\n";
}
if (bearing_1 != " " && bearing_1 != "")
{
Data += "bearing_1: " + bearing_1 + "\n";
}
if (number_of_eyes_1 != " " && number_of_eyes_1 != "")
{
Data += "number_of_eyes_1: " + number_of_eyes_1 + "\n";
}
if (joint_use_anchor_2 != " " && joint_use_anchor_2 != "")
{
Data += "joint_use_anchor_2: " + joint_use_anchor_2 +
"\n";
}
if (proposed_or_existing_2 != " " && proposed_or_existing_2
!= "")
{
Data += "proposed_or_existing_2: " +
proposed_or_existing_2 + "\n";
}
if (anchor_size_2 != " " && anchor_size_2 != "")
{
Data += "anchor_size_2: " + anchor_size_2 + "\n";
}
if (down_guy_wire_size_2 != " " && down_guy_wire_size_2 !=
"")
{
Data += "down_guy_wire_size_2: " + down_guy_wire_size_2
+ "\n";
}
if (lead_2 != " " && lead_2 != "")
{
Data += "lead_2: " + lead_2 + "\n";
}
if (guy_quantity_2 != " " && guy_quantity_2 != "")
{
Data += "guy_quantity_2: " + guy_quantity_2 + "\n";
}
 if (guy_hoa_2 != " " && guy_hoa_2 != "")
{
Data += "guy_hoa_2: " + guy_hoa_2 + "\n";
}
if (pull_2 != " " && pull_2 != "")
{
Data += "pull_2: " + pull_2 + "\n";
}
if (bearing_2 != " " && bearing_2 != "")
{
Data += "bearing_2: " + bearing_2 + "\n";
}
if (number_of_eyes_2 != " " && number_of_eyes_2 != "")
{
Data += "number_of_eyes_2: " + number_of_eyes_2 + "\n";
}
if (joint_use_anchor_3 != " " && joint_use_anchor_3 != "")
{
Data += "joint_use_anchor_3: " + joint_use_anchor_3 +
"\n";
}
if (proposed_or_existing_3 != " " && proposed_or_existing_3
!= "")
{
Data += "proposed_or_existing_3: " +
proposed_or_existing_3 + "\n";
}
if (anchor_size_3 != " " && anchor_size_3 != "")
{
Data += "anchor_size_3: " + anchor_size_3 + "\n";
}
if (down_guy_wire_size_3 != " " && down_guy_wire_size_3 !=
"")
{
Data += "down_guy_wire_size_3: " + down_guy_wire_size_3
+ "\n";
}
if (lead_3 != " " && lead_3 != "")
{
Data += "lead_3: " + lead_3 + "\n";
}
if (guy_quantity_3 != " " && guy_quantity_3 != "")
{
Data += "guy_quantity_3: " + guy_quantity_3 + "\n";
}
if (guy_hoa_3 != " " && guy_hoa_3 != "")
{
Data += "guy_hoa_3: " + guy_hoa_3 + "\n";
}
if (pull_3 != " " && pull_3 != "")
{
Data += "pull_3: " + pull_3 + "\n";
}
if (bearing_3 != " " && bearing_3 != "")
{
Data += "bearing_3: " + bearing_3 + "\n";
}
if (number_of_eyes_3 != " " && number_of_eyes_3 != "")
{
 Data += "number_of_eyes_3: " + number_of_eyes_3 + "\n";
}
if (joint_use_anchor_4 != " " && joint_use_anchor_4 != "")
{
Data += "joint_use_anchor_4: " + joint_use_anchor_4 +
"\n";
}
if (proposed_or_existing_4 != " " && proposed_or_existing_4
!= "")
{
Data += "proposed_or_existing_4: " +
proposed_or_existing_4 + "\n";
}
if (anchor_size_4 != " " && anchor_size_4 != "")
{
Data += "anchor_size_4: " + anchor_size_4 + "\n";
}
if (down_guy_wire_size_4 != " " && down_guy_wire_size_4 !=
"")
{
Data += "down_guy_wire_size_4: " + down_guy_wire_size_4
+ "\n";
}
if (lead_4 != " " && lead_4 != "")
{
Data += "lead_4: " + lead_4 + "\n";
}
if (guy_quantity_4 != " " && guy_quantity_4 != "")
{
Data += "guy_quantity_4: " + guy_quantity_4 + "\n";
}
if (guy_hoa_4 != " " && guy_hoa_4 != "")
{
Data += "guy_hoa_4: " + guy_hoa_4 + "\n";
}
if (pull_4 != " " && pull_4 != "")
{
Data += "pull_4: " + pull_4 + "\n";
}
if (bearing_4 != " " && bearing_4 != "")
{
Data += "bearing_4: " + bearing_4 + "\n";
}
if (number_of_eyes_4 != " " && number_of_eyes_4 != "")
{
Data += "number_of_eyes_4: " + number_of_eyes_4 + "\n";
}
if (telco_first_attachment != " " && telco_first_attachment
!= "")
{
Data += "telco_first_attachment: " +
telco_first_attachment + "\n";
}
if (telco_second_attachment != " " &&
telco_second_attachment != "")
{
Data += "telco_second_attachment: " +
telco_second_attachment + "\n";
}
 if (roadside_attachment != " " && roadside_attachment !=
"")
{
Data += "roadside_attachment: " + roadside_attachment +
"\n";
}
if (catv_first_attachment != " " && catv_first_attachment !
= "")
{
Data += "catv_first_attachment: " +
catv_first_attachment + "\n";
}
if (catv_second_attachment != " " && catv_second_attachment
!= "")
{
Data += "catv_second_attachment: " +
catv_second_attachment + "\n";
}
if (roadside_attachment_2 != " " && roadside_attachment_2 !
= "")
{
Data += "roadside_attachment_2: " +
roadside_attachment_2 + "\n";
}
if (provider_1 != " " && provider_1 != "")
{
Data += "provider_1: " + provider_1 + "\n";
}
if (hoa_1 != " " && hoa_1 != "")
{
Data += "hoa_1: " + hoa_1 + "\n";
}
if (provider_2 != " " && provider_2 != "")
{
Data += "provider_2: " + provider_2 + "\n";
}
if (hoa_2 != " " && hoa_2 != "")
{
Data += "hoa_2: " + hoa_2 + "\n";
}
if (provider_3 != " " && provider_3 != "")
{
Data += "provider_3: " + provider_3 + "\n";
}
if (hoa_3 != " " && hoa_3 != "")
{
Data += "hoa_3: " + hoa_3 + "\n";
}
if (provider_4 != " " && provider_4 != "")
{
Data += "provider_4: " + provider_4 + "\n";
}
if (hoa_4 != " " && hoa_4 != "")
{
Data += "hoa_4: " + hoa_4 + "\n";
}
if (provider_5 != " " && provider_5 != "")
{
Data += "provider_5: " + provider_5 + "\n";
 }
if (hoa_5 != " " && hoa_5 != "")
{
Data += "hoa_5: " + hoa_5 + "\n";
}
if (secondaryneutral != " " && secondaryneutral != "")
{
Data += "secondaryneutral: " + secondaryneutral + "\n";
}
if (streetlight != " " && streetlight != "")
{
Data += "streetlight: " + streetlight + "\n";
}
if (transformer != " " && transformer != "")
{
Data += "transformer: " + transformer + "\n";
}
if (ground != " " && ground != "")
{
Data += "ground: " + ground + "\n";
}
if (general_notes != " " && general_notes != "")
{
Data += "general_notes: " + general_notes + "\n";
}
if (damage_notes != " " && damage_notes != "")
{
Data += "damage_notes: " + damage_notes + "\n";
}
}
lines++;
}
return [Link]();
}
catch (Exception Ex)
{
[Link](Ex + "");
return "Explote";
}
}

public string Pole_Photo(Double Lat, Double Lon, string s)

{
try
{
string Data = "";
var reader = new StreamReader(s);
int lines = 0;

while (![Link])
{
string line = [Link]();
string[] values = [Link](',');

if (lines == 0)
for (int c = 0; c < [Link]; c++)
if (values[c] == "photo")
photo_p = c;
 else if (values[c] == "latitude")
latitude_p = c;
else if (values[c] == "longitude")
longitude_p = c;
if (lines != 0)
{
decimal lat1 = [Link]([Link](Lat), 5);
decimal lon1 = [Link]([Link](Lon), 5);

decimal lat2 =
[Link]([Link](values[latitude_p]), 5);
decimal lon2 =
[Link]([Link](values[longitude_p]), 5);

if ([Link]([Link](lat1 - lat2)) <= 0.0002 &&

[Link]([Link](lon1 - lon2)) <= 0.0002)
{
Data = values[photo_p];
return Data;
}
}
lines++;
}
return [Link]();
}
catch (Exception Ex)
{
[Link](Ex + "");
return "Explote";
}
}

public string Dow_Anc_Detail(string S, int P)

{
try
{
string Data = "";
var reader = new StreamReader(S);
int lines = 0;

while (![Link])
{
string line = [Link]();
string[] values = [Link](',');

if (lines == 0)
for (int c = 0; c < [Link]; c++)
if (values[c] == "proposed_or_existing_1")
proposed_or_existing_1_p = c;
else if (values[c] == "bearing_1")
bearing_1_p = c;
else if (values[c] == "lead_1")
lead_1_p = c;

if (lines == P && P != 0)
{
proposed_or_existing_1 = values[proposed_or_existing_1_p];
bearing_1 = values[bearing_1_p];
lead_1 = values[lead_1_p];
 if (proposed_or_existing_1 == "Proposed")
Data += "PROPOSED DOWNGUY AND ANCHOR AT " + lead_1 + "'
LEAD FROM POLE ";
else if (proposed_or_existing_1 == "Existing")
Data += "EXISTING DOWNGUY BEARING" + " " + bearing_1;
//return Dow_Anc_Details.ToUpper();
}
lines++;
}
return [Link]();
}
catch (Exception Ex)
{
[Link](Ex + "");
return "Explote";
}
}
}

public class CSpan

{
private string environment = " ";
private string aerial_value = " ";

private int environment_p = 0;

private int aerial_value_p = 0;

public string Span_Detail(string S, int P)

{
try
{
string Data = "";
var reader = new StreamReader(S);
int lines = 0;

while (![Link])
{
string line = [Link]();
string[] values = [Link](',');

if (lines == 0)
for (int c = 0; c < [Link]; c++)
if (values[c] == "environment")
environment_p = c;
else if (values[c] == "aerial_value")
aerial_value_p = c;

if (lines == P && P != 0)
{
environment = values[environment_p];
aerial_value = values[aerial_value_p];

if (environment == "Buried")
Data = "{\\fArial|b1|;\\LDIRECTIONAL BORE -MAX\nBACK
REAMER SIZE =6\" \\P}INSTALL 1\'-2\" HDPE \\PCONDUIT PULL 1-FIBER OPTIC CABLE \\
P(84\" MIN. GROUND COVER)";
else if (environment == "Aerial")
 Data = "{\\fArial|b1|;\\LOVERLASH \\P}OVERLASH 1 - FOC
TO \\PEXISTING STRAND \\P{\\C5;" + aerial_value + "\'}";
}
lines++;
}
return Data;
}
catch (Exception Ex)
{
[Link](Ex + "");
return "Explote";
}
}
}

public class CBuried

{
private string buried_reference = " ";
private int buried_reference_p = 0;
private int buried_ref_notes_p = 0;

private int buried_ref_photos_P = 0;

private int latitude_p = 0;
private int longitude_p = 0;

public string Buried_Detail(string S, int P)

{
string Data = "";

try
{
var reader = new StreamReader(S);
int lines = 0;

while (![Link])
{
string line = [Link]();
string[] values = [Link](',');

if (lines == 0)
for (int c = 0; c < [Link]; c++)
if (values[c] == "buried_reference")
buried_reference_p = c;
else if (values[c] == "buried_ref_notes")
buried_ref_notes_p = c;

if (lines == P && P != 0)
{
buried_reference = values[buried_reference_p];
//buried_ref_notes = values[buried_ref_notes_p];

if (buried_reference != " " /*|| buried_ref_notes != " "*/)

Data += buried_reference /*+ " - " +
buried_ref_notes*/;
}
lines++;
}
return [Link]();
}
 catch (Exception Ex)
{
[Link](Ex + "");
return Data;
}
}

public string Buried_Photo(Double Lat, Double Lon, string s)

{
try
{
string Data = "";
var reader = new StreamReader(s);
int lines = 0;

while (![Link])
{
string line = [Link]();
string[] values = [Link](',');

if (lines == 0)
for (int c = 0; c < [Link]; c++)
if (values[c] == "buried_ref_photos")
buried_ref_photos_P = c;
else if (values[c] == "latitude")
latitude_p = c;
else if (values[c] == "longitude")
longitude_p = c;
if (lines != 0)
{
decimal lat1 = [Link]([Link](Lat), 5);
decimal lon1 = [Link]([Link](Lon), 5);

decimal lat2 =
[Link]([Link](values[latitude_p]), 5);
decimal lon2 =
[Link]([Link](values[longitude_p]), 5);

if ([Link]([Link](lat1 - lat2)) <= 0.0002 &&

[Link]([Link](lon1 - lon2)) <= 0.0002)
{
Data = values[buried_ref_photos_P];
return Data;
}
}
lines++;
}
return [Link]();
}
catch (Exception Ex)
{
[Link](Ex + "");
return "Explote";
}
}
}

public class CClearance

{
 private string midspan_clearance = " ";

private int midspan_clearance_p = 0;

public string Clearance_Detail(string S, int P)

{
string Data = "";

try
{
var reader = new StreamReader(S);
int lines = 0;

while (![Link])
{
string line = [Link]();
string[] values = [Link](',');

if (lines == 0)
for (int c = 0; c < [Link]; c++)
if (values[c] == "midspan_clearance")
midspan_clearance_p = c;

if (lines == P && P != 0)
{
midspan_clearance = values[midspan_clearance_p];
values = midspan_clearance.Split('-');
Data = "Clearance " + values[0] + "\'-" + values[1] + "\"";
return [Link]();
}
lines++;
}
return [Link]();
}
catch (Exception Ex)
{
[Link](Ex + "");
return Data;
}
}
}

public class CPoint

{
private double Lat = 0;
private double Lon = 0;

public double GSLat { get => Lat; set => Lat = value; }
public double GSLon { get => Lon; set => Lon = value; }

public Point3d Regla_3(Polyline Ori, Polyline Des, Point3d Pb)

{
double OriL = [Link] / 100;

double DesL = [Link] / 100;

double Pr = [Link](Pb) / OriL;

return ([Link](DesL * Pr));

 }

public Point3d PointFromLatLong(Point3d Point)

{
var doc = [Link];
var db = [Link];

// Translate the lat-lon to a drawing point

var dwgPt = TranslateGeoPoint(db, Point, false);

return dwgPt;
}

public Point3d PointFromLatLong(double lat, double lon)

{
Point3d Point = new Point3d(lat, lon, 0);

var doc = [Link];

var db = [Link];

// Translate the lat-lon to a drawing point

var dwgPt = TranslateGeoPoint(db, Point, false);

return dwgPt;
}

public Point2d LatLongFromPoint2(Point3d P)

{
var doc = [Link];

var ed = [Link];
var db = [Link];

// Translate the drawing point to a lat-lon

var lonlat = TranslateGeoPoint(db, P, true);

var p = new Point2d(lonlat.X, lonlat.Y);

return p;
}

private Point3d TranslateGeoPoint(Database db, Point3d inPt, bool fromDwg)

{
using (var tr = [Link]())
{

// Get the drawing's GeoLocation object

var gd = [Link]([Link], [Link]) as

GeoLocationData;

// Get the output point...

// dwg2lonlat if fromDwg is true,
// lonlat2dwg otherwise

var outPt = (fromDwg ? [Link](inPt) :

[Link](inPt));

[Link]();
 return outPt;
}
}

public double Distance(Point2d A, Point2d B)

{
double Lat1 = 0;
double lon1 = 0;
double Lat2 = 0;
double lon2 = 0;

double deg2radMultiplier = [Link] / 180;

Lat1 *= deg2radMultiplier;
lon1 *= deg2radMultiplier;
Lat2 *= deg2radMultiplier;
lon2 *= deg2radMultiplier;

double radius = 6378.137; // earth mean radius defined by WGS84

            double dlon = lon2 - lon1;
double distance = [Link]([Link](Lat1) * [Link](Lat2) +
[Link](Lat1) * [Link](Lat2) * [Link](dlon)) * radius;

return (distance);
}

#region Geometric Center of Polyline

public Point3d GetCentroid(Polyline pl)
{
Point2d p0 = pl.GetPoint2dAt(0);
Point2d cen = new Point2d(0.0, 0.0);
double area = 0.0;
double bulge = [Link](0);
int last = [Link] - 1;
double tmpArea;
Point2d tmpPoint;

if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, 0, 1);
area = datas[0];
cen = new Point2d(datas[1], datas[2]) * datas[0];
}
for (int i = 1; i < last; i++)
{
tmpArea = TriangleAlgebricArea(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
tmpPoint = TriangleCentroid(p0, pl.GetPoint2dAt(i),
pl.GetPoint2dAt(i + 1));
cen += (tmpPoint * tmpArea).GetAsVector();
area += tmpArea;
bulge = [Link](i);
if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, i, i + 1);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
 }
}
bulge = [Link](last);
if (bulge != 0.0)
{
double[] datas = GetArcGeom(pl, bulge, last, 0);
area += datas[0];
cen += new Vector2d(datas[1], datas[2]) * datas[0];
}
cen = [Link](area);
Point3d result = new Point3d(cen.X, cen.Y, [Link]);
return [Link]([Link]([Link]));
}

private static double[] GetArcGeom(Polyline pl, double bulge, int index1,

int index2)
{
CircularArc2d arc = (pl.GetArcSegment2dAt(index1));
double arcRadius = [Link];
Point2d arcCenter = [Link];
double arcAngle = 4.0 * [Link](bulge);
double tmpArea = ArcAlgebricArea(arcRadius, arcAngle);
Point2d tmpPoint = ArcCentroid(pl.GetPoint2dAt(index1),
pl.GetPoint2dAt(index2), arcCenter, tmpArea);
return new double[3] { tmpArea, tmpPoint.X, tmpPoint.Y };
}

private static Point2d TriangleCentroid(Point2d p0, Point2d p1, Point2d p2)

{
return (p0 + [Link]() + [Link]()) / 3.0;
}

private static double TriangleAlgebricArea(Point2d p0, Point2d p1, Point2d

p2)
{
return (((p1.X - p0.X) * (p2.Y - p0.Y)) - ((p2.X - p0.X) * (p1.Y -
p0.Y))) / 2.0;
}

private static Point2d ArcCentroid(Point2d start, Point2d end, Point2d cen,

double tmpArea)
{
double chord = [Link](end);
double angle = (end - start).Angle;
return Polar2d(cen, angle - ([Link] / 2.0), (chord * chord * chord) /
(12.0 * tmpArea));
}

private static double ArcAlgebricArea(double rad, double ang)

{
return rad * rad * (ang - [Link](ang)) / 2.0;
}

private static Point2d Polar2d(Point2d org, double angle, double distance)

{
return org + new Vector2d(distance * [Link](angle), distance *
[Link](angle));
}
 #endregion
}

public class CStations

{
private string station_reference = " ";

private int station_referenceP = 0;

private string sta = " ";

private int staP = 0;

public string STATIONS_Detail(string SF, int P)

{
string Data = "";

try
{
var reader = new StreamReader(SF);
int lines = 0;

while (![Link])
{
string line = [Link]();
string[] values = [Link](',');

if (lines == 0)
for (int c = 0; c < [Link]; c++)
if (values[c] == "station_reference")
station_referenceP = c;
else if (values[c] == "sta")
staP = c;

if (lines == P && P != 0)
{
station_reference = values[station_referenceP];
sta = values[staP];
Data = (station_reference + "\n" + sta).ToString();
return [Link]();
}
lines++;
}
return [Link]();
}
catch (Exception Ex)
{
[Link](Ex + "");
return Data;
}
}
}

public class CLayer

{
public void GetLayerName(ComboBox CbLayer)
{
ArrayList Layers = new ArrayList();
// Get the current document and database
 var doc = [Link];
var db = [Link];

// Start a transaction
using (Transaction acTrans = [Link]())
{
// Open the Layer table for read
LayerTable acLyrTbl;
acLyrTbl = [Link]([Link], [Link]) as
LayerTable;
foreach (ObjectId acObjId in acLyrTbl)
{
LayerTableRecord acLyrTblRec;
acLyrTblRec = [Link](acObjId, [Link]) as
LayerTableRecord;
[Link]([Link]);
}
}

foreach (string S in Layers)

[Link](S);
}

public ArrayList GetLayerName()

{
ArrayList Layers = new ArrayList();
// Get the current document and database
var doc = [Link];
var db = [Link];

// Start a transaction
using (Transaction acTrans = [Link]())
{
// Open the Layer table for read
LayerTable acLyrTbl;
acLyrTbl = [Link]([Link], [Link]) as
LayerTable;
foreach (ObjectId acObjId in acLyrTbl)
{
LayerTableRecord acLyrTblRec;
acLyrTblRec = [Link](acObjId, [Link]) as
LayerTableRecord;
[Link]([Link]);
}
}

[Link]();

return Layers;
}

public bool GetLayerOnOff(string layerName)

{
var doc = [Link];
var db = [Link];
using (Transaction acTrans = [Link]())
{
var layerTable = [Link]([Link],
[Link]) as LayerTable;
 var layerTableRecord = [Link](layerTable[layerName],
[Link]) as LayerTableRecord;

return [Link];
}
}
}

public class CBlock

{
public void GetBlockName(ComboBox CbBlock)
{
ArrayList Blocks = new ArrayList();

// Get the current document and database

Document acDoc = [Link];
Database acCurDb = [Link];

// Start a transaction
using (Transaction acTrans =
[Link]())
{
// Open the Layer table for read
BlockTable table =
(BlockTable)[Link]([Link], [Link]);

foreach (ObjectId acObjId in table)

{
BlockTableRecord acLyrTblRec;
acLyrTblRec = [Link](acObjId, [Link]) as
BlockTableRecord;
[Link]([Link]);
}
}

[Link]();

foreach (string S in Blocks)

[Link](S);
}

public ArrayList GetBlockName()

{
ArrayList Blocks = new ArrayList();

// Get the current document and database

Document acDoc = [Link];
Database acCurDb = [Link];

// Start a transaction
using (Transaction acTrans =
[Link]())
{
// Open the Layer table for read
BlockTable table =
(BlockTable)[Link]([Link], [Link]);

foreach (ObjectId acObjId in table)

{
 BlockTableRecord acLyrTblRec;
acLyrTblRec = [Link](acObjId, [Link]) as
BlockTableRecord;
if (![Link]("*"))
[Link]([Link]);
}
}

[Link]();

return Blocks;
}

public string GetBlockName(BlockReference Br)

{
return [Link] ?
((BlockTableRecord)[Link]([Link])).Name :
[Link];
}
}

public class CCSV

{
private string[] headers;

public void Load(TextBox TbLoa, ComboBox CbLongitude, ComboBox CbLatitude)

{
OpenFileDialog openFileDialog = new OpenFileDialog();
[Link] = "Excel Files|
*.xls;*.xlsx;*.xlsm;*.csv;*.txt;*.kml";//Filtro para solo buscar archivos Excel
if ([Link]() == [Link])
{
[Link] = [Link];
[Link] = [Link];
try
{
using (var reader = new StreamReader([Link]))
{
bool header = true;
while (![Link])
{
string line = [Link]();
string[] values = [Link](',');
if (header)
{
headers = values;
header = false;
}
else
{
break;
}
}
}

[Link](headers);
[Link](headers);

[Link] = "latitude";
 [Link] = "longitude";
}
catch (Exception)
{
[Link]("Close file and try");
[Link] = "";
}
}
}
}

public class CKML

{
public int orientation = 0;
public void SimplePolyline(TextBox TBLoadKML)
{
var doc = [Link];
var db = [Link];

using (Transaction acTrans = [Link]())

{
// Open the Block table for read
BlockTable acBlkTbl;
acBlkTbl = [Link]([Link], [Link]) as
BlockTable;

// Open the Block table record Model space for write

BlockTableRecord acBlkTblRec;
acBlkTblRec =
[Link](acBlkTbl[[Link]], [Link]) as
BlockTableRecord;

string s;
using (var reader = new StreamReader([Link]))
{
while (![Link])
{
s = [Link]();

if ([Link]("<coordinates>"))
{
string info = getBetween(s, "<coordinates>",
"</coordinates>");

acBlkTbl = [Link]([Link],
[Link]) as BlockTable;
acBlkTblRec =
[Link](acBlkTbl[[Link]], [Link]) as
BlockTableRecord;
using (Polyline acPoly = new Polyline())
{
[Link] = "ROW";

ArrayList TemArrLis = new ArrayList();

string[] TempArrayData;

string[] j = [Link](' ');

for (int c = 1; c <= [Link] - 2; c++)
{
 TempArrayData = j[c].Split(',');
[Link](TempArrayData[0]);
[Link](TempArrayData[1]);
}

TempArrayData = j[0].Split(',');
[Link](TempArrayData[0]);
[Link](TempArrayData[1]);

int p = 0;

for (int c = 0; c < [Link] - 1; c += 2)

{
Point3d Point = new
Point3d([Link](TemArrLis[c]), [Link](TemArrLis[c + 1]), 0);

[Link] P = new [Link]();

[Link]([Link], new
Point2d([Link](Point).X, [Link](Point).Y), 0, 0, 0);
}

[Link](acPoly);
[Link](acPoly, true);

[Link] = true;
}
}
}
}

[Link]();
[Link]();
}
[Link]();

[Link]("Draw Complete");
}

public string getBetween(string Data, string St, string En)

{
int Start, End;
if ([Link](St) && [Link](En))
{
Start = [Link](St, 0) + [Link];
End = [Link](En, Start);
return [Link](Start, End - Start);
}
else
{
return "";
}
}

public void Draw_Early(TextBox TBLoadKML, Point3d BRP)

{
Polyline acPoly = new Polyline();

var Pol = new Polyline();

 CPoint Cp = new CPoint();
double minddis = 15011515;
string s = "";
int pbm = 0;

using (var reader = new StreamReader([Link]))

while (![Link])
{
s = [Link]();
pbm++;
}

pbm = 0;

var Dm = [Link];
Database Db = [Link];

using (Transaction acTrans = [Link]())

{
BlockTable acBlkTbl;
acBlkTbl = [Link]([Link], [Link]) as
BlockTable;

BlockTableRecord acBlkTblRec;
acBlkTblRec =
[Link](acBlkTbl[[Link]], [Link]) as
BlockTableRecord;

var reader = new StreamReader([Link]);

int NLines = 0;

while (![Link])
{
acPoly = new Polyline();
string Data = [Link]();
pbm++;

string Rute = "";

try
{
if ([Link]("<coordinates>"))
{

Rute = getBetween(Data, "<coordinates>",

"</coordinates>");

ArrayList TemArrLis = new ArrayList();

string[] TempArrayData;

string[] j = [Link](' ');

for (int c = 0; c < [Link]; c++)
{
TempArrayData = j[c].Split(',');
[Link](TempArrayData[0]);
[Link](TempArrayData[1]);
}

for (int c = 0; c < [Link] - 1; c += 2)

 {
Point3d Point = new
Point3d([Link](TemArrLis[c]), [Link](TemArrLis[c + 1]), 0);
[Link]([Link], new
Point2d([Link](Point).X, [Link](Point).Y), 0, 0, 0);
}

Point3d P1 = [Link](BRP, false);

var BRP2 = new Point2d(BRP.X, BRP.Y);

Line l = new Line(P1, BRP);

if ([Link] < minddis)

minddis = [Link];
}
}
catch (Exception ex)
{
[Link]([Link]());
}

NLines++;
}

reader = new StreamReader([Link]);

Polyline[] Lines = new Polyline[NLines];

NLines = 1;

while (![Link])
{
acPoly = new Polyline();

var Data = [Link]();

pbm++;

var Rute = "";

try
{
if ([Link]("<coordinates>"))
{

Rute = getBetween(Data, "<coordinates>",

"</coordinates>");

ArrayList TemArrLis = new ArrayList();

string[] TempArrayData;

string[] j = [Link](' ');

for (int c = 0; c < [Link]; c++)
{
TempArrayData = j[c].Split(',');
[Link](TempArrayData[0]);
[Link](TempArrayData[1]);
}

for (int c = 0; c < [Link] - 1; c += 2)

{
 Point3d Point = new
Point3d([Link](TemArrLis[c]), [Link](TemArrLis[c + 1]), 0);
[Link]([Link], new
Point2d([Link](Point).X, [Link](Point).Y), 0, 0, 0);
}

Point3d P1 = [Link](BRP, false);

var BRP2 = new Point2d(BRP.X, BRP.Y);

Line l = new Line(P1, BRP);

if ([Link] == minddis)
{
Lines[0] = new Polyline();
Lines[0] = acPoly;
}
else
{
Lines[NLines] = new Polyline();
Lines[NLines] = acPoly;
NLines++;
}
}
}
catch (Exception ex)
{
[Link]([Link]());
}
}

bool Fin = false;

int Poliline = 1;

OffSet(Lines[0], BRP, acTrans, acBlkTblRec, minddis);

while (!Fin)
{
try
{
Lines[0].JoinEntity(Lines[Poliline]);
//OffSet(Lines[Poliline], BRP, acTrans, acBlkTblRec,
minddis, OLines);

OffSet(Lines[0], BRP, acTrans, acBlkTblRec, minddis);

}
catch (Exception ex)
{
//[Link]([Link]());
}
finally
{
Poliline++;
}

if (Poliline == NLines - 1)
Fin = true;
}

Fin = false;
 while (!Fin)
{
try
{
Lines[0].JoinEntity(Lines[Poliline]);
//OffSet(Lines[Poliline], BRP, acTrans, acBlkTblRec,
minddis, OLines);
}
catch (Exception)
{

}
finally
{
Poliline--;
}

if (Poliline == 0)
Fin = true;
}

[Link](Lines[0]);
[Link](Lines[0], true);

[Link]();
}

[Link]("Drawing Complete");
}

public void OffSet(Polyline Lines, Point3d BRP, Transaction acTrans,

BlockTableRecord acBlkTblRec, double minddis, Polyline P0)
{
try
{
var Dm = [Link];
Editor editor = [Link];
Point3d viewDir =
(Point3d)[Link]("VIEWDIR");
orientation = [Link](Lines as Curve,
[Link]([Link]), [Link]()) ? 1 : -
1;

DBObjectCollection acDbObjColl = [Link](minddis *

orientation);

foreach (Entity acEnt in acDbObjColl)

{
double Xdif;
double Ydif;

double min;

var pl = (acEnt) as Polyline;

Point3d Sp = [Link];
 Point3d Ep = [Link];

Polyline l1 = new Polyline();

[Link]([Link], new
Point2d([Link].X, [Link].Y), 0, 0, 0);

[Link]([Link], new
Point2d([Link](Ep, false).X, [Link](Ep, false).Y), 0,
0, 0);

if ([Link] > minddis * 2 - 1 && [Link] < minddis * 2 + 1)

{
Xdif = [Link].X - [Link].X;
Ydif = [Link].Y - [Link].Y;
}
else
{
[Link] = Sp;
[Link] = [Link](Sp, false);

Xdif = [Link].X - [Link].X;

Ydif = [Link].Y - [Link].Y;
}

Polyline PL = new Polyline();

[Link]([Link], new Point2d((Sp.X + Xdif),

(Sp.Y + Ydif)), 0, 0, 0);

[Link]([Link], new Point2d((Ep.X + Xdif),

(Ep.Y + Ydif)), 0, 0, 0);

[Link](PL);
[Link](PL, true);

[Link](PL);

}
}
catch (Exception ex)
{
[Link]([Link]());
}
}

public Line OffSet(Polyline Lines, Point3d BRP, Transaction acTrans,

BlockTableRecord acBlkTblRec, double minddis)
{
var Dm = [Link];
Editor editor = [Link];
Point3d viewDir = (Point3d)[Link]("VIEWDIR");
orientation = [Link](Lines as Curve,
[Link]([Link]), [Link]()) ? 1 : -
1;

DBObjectCollection acDbObjColl = [Link](minddis *

orientation);

Polyline Pl = new Polyline();

foreach (Entity acEnt in acDbObjColl)

{
Pl = (acEnt) as Polyline;
[Link](Pl);
[Link](Pl, true);
}

Line L = new Line();

[Link] = [Link];
[Link] = [Link];
return L;
}
}

public class CParcel

{
public string Id;

public Polyline Body;

public bool Status = false;

public Point3d Cp;

public string Cable;

public string Type;

public CParcel(Polyline body)

{
Body = body;
}

public CParcel()
{

public void SetId(List<MText> Text, Polyline Pr)

{
double max = 0;
double min = 1000;

Point3d SP = new Point3d();

Point3d Ep = new Point3d();

Line L;

for (int c = 0; c < [Link]; c++)

{
L = new Line(Body.GetPoint3dAt(c),
[Link](Body.GetPoint3dAt(c), false));
if ([Link] > max)
{
max = [Link];
 Ep = [Link];
}
else if ([Link] < min)
{
min = [Link];
SP = [Link];
}
}

L = new Line(SP, Ep);

SP = [Link]([Link] / 2);

//max = 1000;
min = 1000;

foreach (MText T in Text)

{
L = new Line(SP, [Link]);
if ([Link] < min)
{
min = [Link];
string[] Data = [Link]('\n');
Id = Data[0];

Cp = new Point3d([Link].X, [Link].Y + 10, 0);

}
}
}
}

public class CCable

{
public string Id;

public string Parent;

public Polyline Body;

public Polyline Buffer;

public bool Status = false;

public CCable()
{

public CCable(Polyline body, string id, string parent)

{
Body = body;
Id = id;
Parent = parent;
}

public override string ToString()

{
return "Id: " + Id + " Parent: " + Parent + " Status:" +
[Link]();
}
}

public class CHH

{
public string Id;

public CHH Terminal;

public Point3d Body;

public string Fibers;

public string Station;

public string type;

public List<CParcel> Parcels = new List<CParcel>();

public CHH()
{
}
}

class CDatabase
{
//Local Database
static SQLiteConnection conn;
static SQLiteDataReader dr;
static SQLiteCommand cmd;
static [Link] dt;
public string DataSource = (@"C:\GenXCTool\DB\Plannin");

public CDatabase(string dataSource)

{
DataSource = dataSource;
}

public CDatabase()
{
}

//If there's any error, Write a Log

public static void Log(string text)

{
string file = @"C:\GenXCTool\DB\[Link]";
string txt = text;

[Link](file, txt + "\n");

}

//Functions Local Database

public void conect()
{
try
{
string Coneccion = ("Data Source = " + DataSource);
 conn = new SQLiteConnection(Coneccion);
[Link]();
}

catch (Exception Ex)

{
[Link]("Error al conectar con la base de datos= " +
[Link]());
}
}

public void Save(string commd)

{
conect();

cmd = new SQLiteCommand(commd, conn);

[Link]();

[Link]();
}

public void eliminar(string commd)

{
conect();

cmd = new SQLiteCommand(commd, conn);

[Link]();

[Link]();
}

public void Update(string commd)

{
conect();

cmd = new SQLiteCommand(commd, conn);

[Link]();

[Link]();

public [Link] Select(string commd)

{
conect();

cmd = new SQLiteCommand(commd, conn);

dr = [Link]();

dt = new [Link]();

[Link](dr);

[Link]();

return dt;
}
 public Boolean Existe(string commd)
{
try
{
int q = 0;
conect();
cmd = new SQLiteCommand(commd, conn);
dr = [Link]();
while ([Link]())
{
q++;
}

if (q == 0)
return false;
else
return true;
}

catch (Exception Ex)

{
//[Link]("Error al Cargar datos de la base de datos = " +
[Link]());

[Link](@"C:\GenXCTool\Temp Arc\[Link]", commd + "\

n");

return false;
}

finally
{
[Link]();
}
}
}

public class CPostgres

{
static [Link] Con;
//static SQLiteDataAdapter Da;
static SQLiteDataReader Dr;
static SQLiteCommand Com;
static string DataSource = @"C:\GenXCTool\DB\[Link]";
//static string DataSource = @"C:\GenXCTool\DB\[Link]";
//static string DataSource1 = @"C:\Users\genxc\OneDrive - GenXC Group\
Documents - IT\GenXC Apps\Dinanyeli\[Link]";

public void ClassDB(string Ds)

{
DataSource = Ds;
}

public void ClassDB()

{

}
 public static void Ds(string Ds)
{
DataSource = Ds;
}

public void Conectar(string DataSource)

{
try
{
string Conexion = ("Data Source = " + DataSource);
Con = new [Link](Conexion);
[Link]();
//[Link]("done");
}
catch (Exception Ex)
{
[Link]("Error al conectar con la base de datos= " +
[Link]());
}
}

public void Set(string query, string DataSource)

{
try
{
Conectar(DataSource);
Com = new SQLiteCommand(query, Con);
[Link]();
}
catch (Exception Ex)
{
[Link]("Error al guardar en la base de datos= " +
[Link]() + "\n" + query);
}
finally
{
[Link]();
}
}
public void Guardar(string query)
{
try
{
Conectar(DataSource);
Com = new SQLiteCommand(query, Con);
[Link]();
[Link]("Cambios guardados Correctamente", "Guardar",
[Link], [Link]);
}
catch (Exception Ex)
{
[Link]("Error al guardar en la base de datos= " +
[Link]() + "\n" + query);
}
finally
{
[Link]();
}
 }
public Boolean Existe(string query)
{
try
{
int q = 0;
Conectar(DataSource);
Com = new SQLiteCommand(query, Con);
Dr = [Link]();
while ([Link]())
{
q++;
}
if (q == 0)
return false;
else
return true;
}
catch (Exception Ex)
{
[Link]("Error al Cargar datos de la base de datos = " +
[Link]());
return false;
}
finally
{
[Link]();
}
}
#region Foto

public Byte[] Get(string query)

{
Byte[] Dat = null;

try
{
Conectar(DataSource);
Com = new SQLiteCommand(query, Con);
Dr = [Link]();
while ([Link]())
{
Dat = (byte[])Dr[0];
}
}
catch (Exception Ex)
{
[Link]("Error al Conectar en la base de datos= " +
[Link]());
}
finally
{
[Link]();
}
return Dat;
}
public void GuardarFoto(byte[] B)
{
try
 {
Conectar(DataSource);
Com = new SQLiteCommand("Insert into Imagen Values(@imagen)", Con);
[Link]("@imagen", B);
[Link]();
[Link]("Cambios guardados Correctamente", "Guardar",
[Link], [Link]);
}
catch (Exception Ex)
{
[Link]("Error al guardar en la base de datos= " +
[Link]());
}
finally
{
[Link]();
}
}
#endregion
public SQLiteCommand select(string query, string DataSource)
{
try
{
Conectar(DataSource);
Com = new SQLiteCommand(query, Con);
[Link]();
}
catch (Exception Ex)
{
[Link]("Error al guardar en la base de datos= " +
[Link]());
}
finally
{
//[Link]();
}

return Com;
}

public void ExecuteQuery(string txtQuery)

{
Conectar(DataSource);
Com = [Link]();
[Link] = txtQuery;
[Link]();
[Link]();
}

public [Link] Datatable1(string cod, string DataSource)

{
[Link] dt = new [Link]();
DataSet ds = new DataSet();
Conectar(DataSource);
Com = [Link]();

SQLiteDataAdapter DB = new SQLiteDataAdapter(cod, Con);

[Link]();
[Link](ds);
 dt = [Link][0];
[Link]();

return dt;
}

public void Dispose()

{
[Link]();
}
}

class CPolyline
{
public static void Lin2Pol(Polyline Pl, Line L)
{
[Link]([Link], (new Point2d([Link].X,
[Link].Y)), 0, 0, 0);

[Link]([Link], (new Point2d([Link].X,

[Link].Y)), 0, 0, 0);

[Link] = [Link];
}
}

class CLayout
{
CBlock cBlock = new CBlock();

DBObjectCollection DB0 = new DBObjectCollection();

bool Layn = true;

CCentroide centroide = new CCentroide();

CPoint cPoint = new CPoint();

string Page = "";

public void Create_Viewport_Auto(CTransaction Trans, string Typ)

{
bool J = true;

int ViewportN = 0;

ArrayList Conts = new ArrayList();

while (J)
{
PromptSelectionOptions promptPointOptions = new
PromptSelectionOptions();
[Link] = ("Select Cable");
PromptSelectionResult selectLinesFollow =
[Link](promptPointOptions);
if ([Link] == [Link])
{
foreach (ObjectId Obj in
[Link]())
 {
DBObject entity = [Link](Obj,
[Link]);
if (entity is Polyline)
{
Polyline Pl = (Polyline)entity;

double Cont = 0;

//List<BlockReference> Vports = new

List<BlockReference>();

PromptSelectionResult selectLinesFollow3 =
[Link]();
if ([Link] == [Link])
{
foreach (ObjectId Obj3 in
[Link]())
{
DBObject entity3 =
[Link](Obj3, [Link]);
if (entity3 is BlockReference)
{
BlockReference Br =
(BlockReference)entity3;

string name = [Link] ?

((BlockTableRecord)[Link]([Link])).Name :
[Link];

if (name == "Vport")
{
Point3dCollection AB = new
Point3dCollection();

DBObjectCollection dBObjectCollection =
new DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Db in
dBObjectCollection)
{
if (Db is Polyline)
{
Polyline Tpl = (Polyline)Db;

[Link](Pl,
[Link], AB, [Link], [Link]);

if ([Link] > 0)
{
foreach (Point3d P in AB)
{
if
([Link](P) > Cont)
{
Cont =
[Link](P);
 }
}
}
}
}

foreach (ObjectId attId in

[Link])
{
var acAtt =
[Link](attId, [Link]) as AttributeReference;
if ([Link] == "PAGE")
{
if
(Convert.ToInt32([Link]) > ViewportN)
ViewportN =
Convert.ToInt32([Link]);
}
}
}
}
}
}

ViewportN = ViewportN + 1;

while (Cont < [Link])

{
bool LengF = false;

ObjectId ObjId = [Link]["Vport"];

BlockReference Br = new
BlockReference([Link](Cont), ObjId);

[Link] = "Vport";

if ([Link] != new Point3d(0, 0, 0))

{
Line TempAngle = new Line();

if ([Link] > Cont + 50)

{
TempAngle = new
Line([Link](Cont), [Link](Cont + 50));
}
else if (Cont - 50 > 0)
{
TempAngle = new Line([Link](Cont
- 50), [Link](Cont));
LengF = true;
}

double RealAngle = 0;

RealAngle = [Link];

if(Typ == "360")
{
 [Link] = RealAngle;
}

if(Typ == "0_90")
{
if (RealAngle >= 0 && RealAngle <=
[Link] / 180 * 45)
{
[Link] = 0;
}

else if (RealAngle >= [Link] / 180 * 315)

{
[Link] = 0;
}

else if (RealAngle >= [Link] / 180 * 135

&& RealAngle <= [Link] / 180 * 225)
{
[Link] = [Link] / 180 * 180;
}

else if (RealAngle > [Link] / 180 * 45 &&

RealAngle < [Link] / 180 * 135)
{
[Link] = [Link] / 180 * 90;
}

else if (RealAngle > [Link] / 180 * 225 &&

RealAngle < [Link] / 180 * 315)
{
[Link] = [Link] / 180 * 270;
}
}
else if (Typ == "0")
{
Point3d Pos = new Point3d(0, 0, 0);

DBObjectCollection DbObjCol = new

DBObjectCollection();

[Link](DbObjCol);

foreach (DBObject Db in DbObjCol)

{
if (Db is Polyline)
{
Point3dCollection AB = new
Point3dCollection();

Polyline Tpl = (Polyline)Db;

double Hi =
[Link](2) - [Link](1);
double Le =
[Link](1);

Pos = new Point3d([Link].X -

Le / 2, [Link].Y - Hi / 2, [Link].Z);
 }
}

Br = new BlockReference(Pos, ObjId);

[Link] = "Vport";

[Link] = 0;

[Link](Br, true);

foreach (ObjectId attId in

[Link])
{
var acAtt =
[Link](attId, [Link]) as AttributeReference;
if ([Link] == "PAGE")
{
[Link] =
[Link]("000");
ViewportN++;
}
}

DBObjectCollection dBObjectCollection = new

DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Db in dBObjectCollection)

{
if (Db is Polyline)
{
Point3dCollection AB = new
Point3dCollection();

Polyline Tpl = (Polyline)Db;

[Link](Pl,
[Link], AB, [Link], [Link]);

if ([Link] > 0)
{
List<Point3d> LIP = new
List<Point3d>();

foreach (Point3d P in AB)

{
if ([Link](P) >
Cont)
Cont =
[Link](P);
}
}
}
 }

if ())
{
[Link]([Link]());
}
else
{
Cont += Cont;
}

if (LengF)
Cont += [Link];
}
}
}
}
}
else
{
J = false;
}

J = false;
}
}

public void Create(CTransaction Trans)

{
List<BlockReference> LVp = Get_LVp(Trans);

while(Layn)
{
BlockReference Used_Vport = Get_Used_Vport(Trans, LVp);

if(Layn)
{
Create_Layout(Trans, Used_Vport);

SetLayoutOrder(Trans);

Create_Cover(Trans, Page);

Create_MatchLine(Trans, Used_Vport, LVp);

Create_North(Trans, Used_Vport);
}
}
}

public List<BlockReference> Get_LVp(CTransaction Trans)

{
List<BlockReference> LViewPort = new List<BlockReference>();

PromptSelectionResult selectLinesFollow = [Link]();

if ([Link] == [Link])
{
foreach (ObjectId objectid in
[Link]())
{
DBObject entityp = [Link](objectid,
[Link]);
if (entityp is BlockReference)
{
BlockReference Br = (BlockReference)entityp;

if ([Link](Br) == "Vport")
[Link](entityp as BlockReference);
}
}
}

return LViewPort;
}

public BlockReference Get_Used_Vport(CTransaction Trans,

List<BlockReference> LVp)
{
BlockReference Used_Vport = new BlockReference(new Point3d(0, 0, 0),
[Link]["Vport"]);

double NearVport = 500;

PromptPointOptions promptPointOptions = new

PromptPointOptions("Point");
PromptPointResult selectStartPoint =
[Link](promptPointOptions);
if ([Link] == [Link])
{
Point3d P3d = [Link];

foreach (BlockReference Pl in LVp)

{
Point3dCollection P3dc = new Point3dCollection();

DBObjectCollection DB02 = new DBObjectCollection();

[Link](DB02);

foreach (DBObject Db in DB02)

{
if (Db is Polyline)
{
Polyline Tpol = (Polyline)Db;

Point3d Pc_Polyline_viewport =
[Link](Tpol);

if (new Line(Pc_Polyline_viewport, P3d).Length <

NearVport)
{
NearVport = new Line([Link], P3d).Length;
Used_Vport = Pl;
}
}
}
}
 }
else
{
Layn = false;
}

return Used_Vport;
}

private void Create_Layout(CTransaction Trans, BlockReference Used_Vport)

{
Viewport Vport = new Viewport();

Polyline PLC = new Polyline();

//Get Page In Vport

{
foreach (ObjectId attId in Used_Vport.AttributeCollection)
{
var acAtt = [Link](attId,
[Link]) as AttributeReference;
if ([Link] == "PAGE")
{
Page = [Link];
}
}
}

//Get Polyline In Vport

{
DBObjectCollection DBOC = new DBObjectCollection();

Used_Vport.Explode(DBOC);

foreach (DBObject Db in DBOC)

{
if (Db is Polyline)
{
PLC = (Polyline)Db;
}
}
}

Point2d PC2d = centroide.GetCentroid_2d(PLC);

[Link]("TILEMODE", 0);
[Link]();

LayoutManager acLayoutMgr = [Link];

if ([Link](Page))
{
[Link](Page);
}

// Create the new layout with default settings

ObjectId objID = [Link](Page);
//lo coloque yo
Layout Aclayout = [Link](objID, [Link])
as Layout;

//Set the layout current if it is not already

[Link] = Page;

//Set Page Setup

{
DBDictionary acPlSet =
[Link]([Link],
[Link]) as DBDictionary;

if ([Link]("11 X 17") == true)

{
PlotSettings plSet = [Link]("11 X
17").GetObject([Link]) as PlotSettings;

[Link]();
[Link](plSet);
}
}

//Creando y alineando Layout

{
var vpIds = [Link]();
//configurando los viewports existentes
foreach (ObjectId vpId in vpIds)
{
Vport = [Link](vpId, [Link]) as
Viewport;
[Link]();

[Link] = new Point3d(7.0534, 6.1598, 0);

[Link] = 13.3000;
[Link] = 8.3000;

[Link] = (1.0 / 30.0);

Circle C = new Circle();

[Link] = 40;
[Link] = new Point3d(PC2d.X, PC2d.Y, 0);

[Link] = PC2d;

[Link] = true;
}

SpaceAlign_General(Trans, vpIds, PLC);

}
}

private void Create_MatchLine(CTransaction Trans, BlockReference

Used_Vport, List<BlockReference> LVp)
{
Trans.End_Trans();

Trans.Start_Trans();

[Link] = "Model";
 List<Polyline> LRutes = new List<Polyline>();

Point3dCollection P3dc = new Point3dCollection();

Point3dCollection CableIntersectionPoint = new Point3dCollection();

Polyline VpPolyOri = new Polyline();

DB0 = new DBObjectCollection();

Used_Vport.Explode(DB0);

foreach (DBObject Db in DB0)

{
if (Db is Polyline)
{
Polyline Tpol = (Polyline)Db;

for (int i = 0; i < [Link]; i++)

{
[Link](Tpol.GetPoint3dAt(i));
}

[Link](Tpol.GetPoint3dAt(0));

VpPolyOri = Tpol;
}
}

List<Polyline> Lpl = new List<Polyline>();

PromptSelectionResult selectLinesFollow =
[Link](P3dc);

if ([Link] == [Link])
{
[Link]("TILEMODE", 0);
[Link]();

LayoutManager acLayoutMgr = [Link];

[Link] = Page;

foreach (ObjectId objectid in

[Link]())
{
DBObject entityp = [Link](objectid,
[Link]);

if (entityp is Polyline)
{
Polyline polyline = (Polyline)entityp;

if (([Link] == "PROPOSED_AERIAL" || [Link]

== "PROPOSED_UG" || [Link] == "PROPOSED_BURIED") && [Link] > 10)
{
Point3dCollection intersectionPoints = new
Point3dCollection();
[Link](VpPolyOri,
[Link], intersectionPoints, [Link], [Link]);

if ([Link] > 0)
{
foreach (Point3d item in intersectionPoints)
{
[Link](item);
}

[Link](polyline);
}

[Link](polyline);

}
}
}

List<string> ml = new List<string>();

////polilineas
foreach (Polyline Pl in Lpl)
{
List<Point3d> LCorInter = new List<Point3d>();

double Max = 0;

double Min = [Link];

Point3dCollection MyCableIntersectionPoint = new

Point3dCollection();

foreach (Point3d Pd3 in CableIntersectionPoint)

{
if ([Link](Pd3, false) == Pd3)
{
if ([Link](Pd3) > Max)
Max = [Link](Pd3);
else if ([Link](Pd3) < Min)
Min = [Link](Pd3);

[Link](Pd3);
}
}

double Dc = Max - Min;

List<BlockReference> LVportVec = new List<BlockReference>();

foreach (BlockReference Br in LVp)

{
DBObjectCollection dBObjectCollection = new
DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Obj in dBObjectCollection)

{
 if (Obj is Polyline)
{
Polyline polyline = Obj as Polyline;

Point3dCollection intersectionPoints = new

Point3dCollection();
[Link](Pl,
[Link], intersectionPoints, [Link], [Link]);

if ([Link] > 0)
{
[Link](Br);
}
}
}
}

for (int i = 0; i < [Link]; i++)

{
for (int i2 = i; i2 < [Link]; i2++)
{
if
([Link]([Link](LVportVec[i].Position, false)) >
[Link]([Link](LVportVec[i2].Position, false)))
{
BlockReference Tem = LVportVec[i];
LVportVec[i] = LVportVec[i2];
LVportVec[i2] = Tem;
}
}
}

for (int i = 0; i < [Link]; i++)

{
MText mText = new MText();
[Link] = 10;
[Link] = [Link]();
[Link] = LVportVec[i].Position;
//[Link](mText, true);

foreach (ObjectId attId in

LVportVec[i].AttributeCollection)
{
var acAtt = [Link](attId,
[Link]) as AttributeReference;
if ([Link] == "PAGE")
{
//[Link]([Link]);
}
}
}

List<BlockReference> LFVportVec = new List<BlockReference>();

List<BlockReference> LFVportVecU = new List<BlockReference>();

for (int i = 0; i < [Link]; i++)

{
foreach (ObjectId attId in
LVportVec[i].AttributeCollection)
{
var acAtt = [Link](attId,
[Link]) as AttributeReference;
if ([Link] == "PAGE")
{
if ([Link] == Page)
{
if (i > 0)
{
[Link](LVportVec[i - 1]);
}

if ([Link] > (i + 1))

{
[Link](LVportVec[i + 1]);
}
}
}
}
}

//[Link]("New Cable");

foreach (BlockReference BR in LFVportVec)

{
foreach (ObjectId attId in [Link])
{
var acAtt = [Link](attId,
[Link]) as AttributeReference;
if ([Link] == "PAGE")
{
// [Link]([Link]);
}
}
}

ArrayList IntvsVport = new ArrayList();

foreach (Point3d point3D in MyCableIntersectionPoint)

{
double Dist = 1500;

string PaGe = "";

BlockReference Tembr;

foreach (BlockReference Br in LFVportVec)

{
if ()
{
DBObjectCollection dBObjectCollection = new
DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Obj in dBObjectCollection)

{
if (Obj is Polyline)
 {
Polyline polyline = Obj as Polyline;

Point3dCollection intersectionPoints = new

Point3dCollection();
[Link](Pl,
[Link], intersectionPoints, [Link], [Link]);

if ([Link] > 0)
{
foreach (Point3d P3f in
intersectionPoints)
{
if (new Line(point3D, P3f).Length <
Dist)
{
Dist = new Line(point3D,
P3f).Length;

foreach (ObjectId attId in

[Link])
{
var acAtt =
[Link](attId, [Link]) as AttributeReference;
if ([Link] == "PAGE")
{
PaGe =
[Link];
}
}
}
}
}
}
}
}
}

foreach (BlockReference Br in LFVportVec)

{
if ()
{
DBObjectCollection dBObjectCollection = new
DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Obj in dBObjectCollection)

{
if (Obj is Polyline)
{
Polyline polyline = Obj as Polyline;

Point3dCollection intersectionPoints = new

Point3dCollection();
[Link](Pl,
[Link], intersectionPoints, [Link], [Link]);

if ([Link] > 0)
 {
foreach (Point3d P3f in
intersectionPoints)
{
if (new Line(point3D, P3f).Length
== Dist)
{
[Link](Br);

foreach (ObjectId attId in

[Link])
{
var acAtt =
[Link](attId, [Link]) as AttributeReference;
if ([Link] == "PAGE")
{

//[Link]([Link]);
}
}

}
}
}
}
}
}
}

[Link]([Link]() + "\n" + PaGe);

}

Polyline Dest = new Polyline();

//rectangulo
ObjectId Obj_Id = [Link]["vPORT2"];

// Insert the block into the current space

if (Obj_Id != [Link])
{
using (BlockReference Br = new BlockReference(new
Point3d(7.0536, 6.1437, 0), Obj_Id))
{
[Link] = new Scale3d(1, 1, 1);

[Link] = "Vport2";

[Link] = [Link] / 180 * 0;

BlockTableRecord Btr =
(BlockTableRecord)[Link]["vPORT2"].GetObject([Link]);

DBObjectCollection dBObjectCollection = new

DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Obj in dBObjectCollection)

{
 if (Obj is Polyline)
{
Dest = Obj as Polyline;
}
}
}
}

//Matchlines

foreach (Point3d P in MyCableIntersectionPoint)

{
bool Der = false;

if
([Link]([Link](cPoint.Regla_3(VpPolyOri, Dest, P),
false)) < [Link](1))
{
Der = true;

}
else if
([Link]([Link](cPoint.Regla_3(VpPolyOri, Dest, P),
false)) < [Link](2))
{
Der = true;
}

string BlockName = "MatchLine";

if (Der)
BlockName = "MatchLine2";

//if ([Link](P, false) == P)

{
Obj_Id = [Link][BlockName];

// Insert the block into the current space

if (Obj_Id != [Link])
{
using (BlockReference Br = new
BlockReference(cPoint.Regla_3(VpPolyOri, Dest, P), Obj_Id))
{
[Link] = "Vport2";
[Link] = new Scale3d(0.8, 0.8, 0.8);

if
([Link]([Link]([Link], false)) <
[Link](1))
{
[Link] = [Link] / 180 * 0;

//[Link] = new Point3d([Link].X,

[Link].Y + 0.1463, 0);

if ([Link].X > 12.4259)

{
[Link] = new Point3d(12.4259,
[Link].Y, 0);
}
else if ([Link].X < 1.8937)
{
[Link] = new Point3d(1.8937,
[Link].Y, 0);
}

//[Link](([Link] / [Link] *
180).ToString());

}
else if
([Link]([Link]([Link], false)) <
[Link](2))
{
[Link] = [Link] / 180 * 270;

//[Link] = new Point3d([Link].X +

0.1463, [Link].Y, 0);

if ([Link].Y < 3.2861)

{
[Link] = new
Point3d([Link].X, 3.2861, 0);
}
else if ([Link].Y > 8.8263)
{
[Link] = new
Point3d([Link].X, 8.8263, 0);
}

//[Link](([Link] / [Link] *
180).ToString());
}
else if
([Link]([Link]([Link], false)) <
[Link](3))
{
[Link] = [Link] / 180 * 0;

//[Link] = new Point3d([Link].X,

[Link].Y - 0.1463, 0);

if ([Link].X > 12.3174)

{
[Link] = new Point3d(12.3174,
[Link].Y, 0);
}
else if ([Link].X < 1.7825)
{
[Link] = new Point3d(1.7825,
[Link].Y, 0);
}

//[Link](([Link] / [Link] *
180).ToString());
}
 else
{
[Link] = [Link] / 180 * 270;

//[Link] = new Point3d([Link].X -

0.1463, [Link].Y, 0);

if ([Link].Y < 3.3957)

{
[Link] = new
Point3d([Link].X, 3.3957, 0);
}
else if ([Link].Y > 8.9395)
{
[Link] = new
Point3d([Link].X, 8.9395, 0);
}

// [Link](([Link] / [Link] *
180).ToString());
}
string Pag = "";

foreach (string S in IntvsVport)

{
if ([Link]([Link]()))
{
Pag = [Link]('\n')[1];
}
}

if ()
{

BlockTable blockTable =
[Link]([Link], [Link]) as
BlockTable;
BlockTableRecord blkTbRecPaper =
[Link](blockTable[[Link]],
[Link]) as BlockTableRecord;
[Link](Br);

BlockTableRecord Btr =
(BlockTableRecord)blockTable[BlockName].GetObject([Link]);

foreach (ObjectId id in Btr)

{
DBObject obj =
[Link]([Link]);
AttributeDefinition attDef = obj as
AttributeDefinition;
if (attDef != null && ![Link])
{
using (AttributeReference attRef =
new AttributeReference())
{

[Link](attDef, [Link]);
 [Link] = true;

[Link](attRef);

[Link](attRef, true);

if ([Link] ==
"DESCRIPTION")
{
[Link] = "SEE
DRAWING# ";
}
else if ([Link] == "PAGE"
|| [Link] == "REF#")
{

[Link] = Pag;
}
else
{
[Link] = "";
}
}
}
}

DynamicBlockReferencePropertyCollection
pcFST = [Link];

foreach (DynamicBlockReferenceProperty dP
in pcFST)
{
if ([Link] == "Flip state1")
{
/* [Link](
$"\nName: {[Link]} " +
$"Type code: {[Link]}
" +
$"Unit type: {[Link]} " +
$"Allowed values: [{[Link](",
", [Link]())}]");*/

//[Link] = "1";
}
}

bool Del = false;

foreach (ObjectId attId in

[Link])
{
var acAtt =
[Link](attId, [Link]) as AttributeReference;
if ([Link] == "PAGE")
{
 if ([Link] == "")
{
Del = true;
}
}
}

if (Del)
{
[Link]();
}
[Link](Pag);
}
}
}
}
}
}
}
}

public void Create_Cover(CTransaction Trans, string Page)

{
Trans.End_Trans();

Trans.Start_Trans();

BlockReference Br = new BlockReference(new Point3d(8.3815, 5.3826, 0),

[Link]["COVER"]);

[Link] = new Scale3d(1, 1, 1);

[Link] = "Vport2";

DynamicBlockReferencePropertyCollection DBRC =
[Link];

foreach (DynamicBlockReferenceProperty prop in DBRC)

{
if ([Link] == "PAGE")
{
[Link] = Page;
}
}

[Link](Br, false);
}

public void Create_North(CTransaction Trans, BlockReference Used_Vport)

{
Trans.End_Trans();

Trans.Start_Trans();

[Link] = "Model";

Point3d PC = new Point3d(0, 0, 0);

PromptSelectionResult PSR = [Link]();

 if ([Link] == [Link])
{
foreach (ObjectId Obj in [Link]())
{
DBObject DbObj = [Link](Obj,
[Link]);

if (DbObj is BlockReference)
{
BlockReference Br = DbObj as BlockReference;

string name = [Link] ?

((BlockTableRecord)[Link]([Link])).Name :
[Link];

if (name == "NORTH ARROW")

{
PC = new Point3d([Link].X, [Link].Y, 0);
}
}
}
}

Line L = new Line();

[Link] = PC;
[Link] = new Point3d(PC.X + 1, PC.Y, PC.Z);

var ang = [Link]([Link]([Link]));

ang = [Link]() * 0.53;
ang = [Link]([Link](Used_Vport.Rotation, [Link],
[Link]));

var Li = new Line([Link](0) + ang, [Link](0) -

ang);

//[Link](Li, true);

Polyline PLC = new Polyline();

[Link]([Link], new Point2d([Link].X,

[Link].Y), 0, 0, 0);
[Link]([Link], new Point2d([Link].X,
[Link].Y), 0, 0, 0);

// [Link](PLC, true);

[Link]("TILEMODE", 0);
[Link]();

LayoutManager acLayoutMgr = [Link];

[Link] = Page;

Layout Aclayout =
[Link]([Link]([Link]),
[Link]) as Layout;

Viewport acVport = new Viewport();

[Link]();
 [Link] = new Point3d(13.1869, 1.5377, 0);
[Link] = 0.8681;
[Link] = 0.8681;
[Link] = 1;

[Link] = new Point2d(PC.X,PC.Y);

[Link](acVport, false);

[Link] = true;

SpaceAlign_General_North(Trans, acVport, PLC);

[Link] = "Model";
}

public void SpaceAlign2(Polyline Pl, Viewport Vp)

{
var doc = [Link];
var db = [Link];
var ed = [Link];
var documentloc = [Link]();

ArrayList Lp = new ArrayList();

using (var tr = [Link]())

{
{
var modelPt1 =
[Link](([Link](Pl.GetPoint3dAt(1)) +
[Link](Pl.GetPoint3dAt(2))) / 2);
Circle C = new Circle();
[Link] = 15;
[Link] = modelPt1;
//[Link](C, true);

var modelPt2 =
[Link](([Link](Pl.GetPoint3dAt(3)) + [Link]) / 2);
C = new Circle();
[Link] = 15;
[Link] = modelPt2;
//[Link](C, true);

modelPt1 =
[Link]([Link]);
modelPt2 =
[Link]([Link]);

C = new Circle();
[Link] = 15;
[Link] = [Link](Pl);
//[Link](C, true);

// [Link]();
 var paperPt2 = new Point3d(1.2694, 6.1092, 0);
C = new Circle();
[Link] = 2;
[Link] = paperPt2;
//[Link](C, false);

var paperPt1 = new Point3d(13.5880, 6.1092, 0);

C = new Circle();
[Link] = 2;
[Link] = paperPt1;
//[Link](C, false);

paperPt1 =
[Link]([Link]);
paperPt2 =
[Link]([Link]);

var ucs = [Link];

AlignSpace(Vp, modelPt1, modelPt2, paperPt1, paperPt2);

//[Link]();
}
[Link]();
}
}

private void SetLayoutOrder(CTransaction Trans)

{
string[] array =
((IEnumerable<string>)GetLayoutNames()).OrderBy<string, string>((Func<string,
string>)(l => l)).ToArray<string>();
Database workingDatabase = [Link];
LayoutManager current = [Link];
int num = 1;
foreach (string name in array)
{
([Link]([Link](name),
[Link]) as Layout).TabOrder = num;
++num;
}
}

public string[] GetLayoutNames()

{
List<Layout> source = new List<Layout>();
Database workingDatabase = [Link];
using (Transaction transaction =
[Link]())
{
foreach (DBDictionaryEntry dbDictionaryEntry in
(DBDictionary)[Link]([Link],
[Link]))
{
ObjectId id = [Link];
[Link]([Link](id,
[Link]) as Layout);
}
[Link]();
}
 int count = [Link];
return [Link]<Layout>((Func<Layout, bool>)(l =>
[Link]() != "MODEL")).Select<Layout, string>((Func<Layout, string>)(l
=> [Link])).ToArray<string>();
}

public void SpaceAlign_General(CTransaction Trans, ObjectIdCollection

vpIds, Polyline Pl)
{

foreach (ObjectId vpId in vpIds)

{
Viewport Vport = [Link](vpId,
[Link]) as Viewport;

var modelPt1 =
[Link]([Link](Pl.GetPoint3dAt(3)) + ([Link] -
[Link](Pl.GetPoint3dAt(3))) / 2);
//[Link] += [Link]() + "\n";

var modelPt2 =
[Link]([Link](Pl.GetPoint3dAt(1)) +
([Link](Pl.GetPoint3dAt(2)) - [Link](Pl.GetPoint3dAt(1))) /
2);
//[Link] += [Link]() + "\n";

modelPt1 =
[Link]([Link]);
modelPt2 =
[Link]([Link]);

[Link]();

var paperPt1 = new Point3d(0.4044, 6.1601, 0);

//[Link] += [Link]() + "\n";

var paperPt2 = new Point3d(13.7034, 6.1601, 0);

//[Link] += [Link]() + "\n";

//Verify Points
{
Circle C = new Circle
{
Center = modelPt1,
Radius = 5
};

// [Link](C, true);

C = new Circle
{
Center = modelPt2,
Radius = 5
};

// [Link](C, true);

C = new Circle
{
 Center = paperPt1,
Radius = 1
};

// [Link](C, false);

C = new Circle
{
Center = paperPt2,
Radius = 1
};

// [Link](C, false);
}

paperPt1 =
[Link]([Link]);
paperPt2 =
[Link]([Link]);

var ucs = [Link];

AlignSpace(Vport, modelPt1, modelPt2, paperPt1, paperPt2);
}
}

public void SpaceAlign_General_North(CTransaction Trans, Viewport vpIds,

Polyline Pl)
{
var modelPt1 = [Link];
//[Link] += [Link]() + "\n";

var modelPt2 = [Link];

//[Link] += [Link]() + "\n";

modelPt1 =
[Link]([Link]);
modelPt2 =
[Link]([Link]);

[Link]();

var paperPt1 = new Point3d(12.8216, 1.5396, 0);

//[Link] += [Link]() + "\n";

var paperPt2 = new Point3d(13.6897, 1.5396, 0);

//[Link] += [Link]() + "\n";

//Verify Points
{
Circle C = new Circle
{
Center = modelPt1,
Radius = 5
};

// [Link](C, true);

C = new Circle
{
 Center = modelPt2,
Radius = 5
};

// [Link](C, true);

C = new Circle
{
Center = paperPt1,
Radius = 1
};

// [Link](C, false);

C = new Circle
{
Center = paperPt2,
Radius = 1
};

// [Link](C, false);
}

paperPt1 =
[Link]([Link]);
paperPt2 =
[Link]([Link]);

var ucs = [Link];

AlignSpace(vpIds, modelPt1, modelPt2, paperPt1, paperPt2);
}

public void SpaceAlign2(Polyline Pl)

{
//[Link]();

//[Link]([Link]());

var doc = [Link];

var db = [Link];
var ed = [Link];
var documentloc = [Link]();

ArrayList Lp = new ArrayList();

using (var tr = [Link]())

{
Viewport vp;
if ((short)[Link]("cvport") == 1)
{
PromptSelectionOptions promptPointOptions = new
PromptSelectionOptions();
[Link] = ("\nSelect Viewport: ");
PromptSelectionResult selectLinesFollow =
[Link](promptPointOptions);
if ([Link] == [Link])
{
 foreach (ObjectId objectId in
[Link]())
{
DBObject dBObject = [Link](objectId,
[Link]);
if (dBObject is Viewport)
{
vp = (Viewport)[Link](objectId,
[Link]);
[Link]();
[Link]("cvport", [Link]);

/* var ppo = new PromptPointOptions("\nFirst

alignment point in model space: ");
var ppr = [Link](ppo);
if ([Link] != [Link])
return;*/
var modelPt1 = [Link];
//[Link] += [Link]() + "\n";

/* [Link] = "\nSecond alignment point in model

space: ";
[Link] = true;
[Link] = modelPt1;
ppr = [Link](ppo);
if ([Link] != [Link])
return;*/
var modelPt2 = Pl.GetPoint3dAt(2);
//[Link] += [Link]() + "\n";

modelPt1 =
[Link]([Link]);
modelPt2 =
[Link]([Link]);

[Link]();

var paperPt1 = new Point3d(5.8301, 11.219, 0);

////[Link] += [Link]() + "\
n";

var paperPt2 = new Point3d(14.8301, 4.219, 0);

//[Link] += [Link]() + "\n";

paperPt1 =
[Link]([Link]);
paperPt2 =
[Link]([Link]);

var ucs = [Link];

AlignSpace(vp, modelPt1, modelPt2, paperPt1,
paperPt2);

[Link]();
}
}
}
 }
else
{
vp = (Viewport)[Link]([Link],
[Link]);

var modelPt1 = [Link];

var modelPt2 = Pl.GetPoint3dAt(2);

modelPt1 =
[Link]([Link]);
modelPt2 =
[Link]([Link]);

[Link]();

var paperPt1 = new Point3d(5.8301, 11.219, 0);

//[Link] += [Link]() + "\n";

var paperPt2 = new Point3d(14.8301, 4.219, 0);

//[Link] += [Link]() + "\n";

paperPt1 =
[Link]([Link]);
paperPt2 =
[Link]([Link]);

var ucs = [Link];

AlignSpace(vp, modelPt1, modelPt2, paperPt1, paperPt2);

[Link]();

[Link]();
}

//[Link]();
}

private void AlignSpace(Viewport vp, Point3d modelPoint1, Point3d

modelPoint2, Point3d paperPoint1, Point3d paperPoint2)
{
if (![Link])
[Link]();

var locked = [Link];

if (locked) [Link] = false;

modelPoint2 = new Point3d(modelPoint2.X, modelPoint2.Y, modelPoint1.Z);

var psdcs2wcs = DCS2WCS(vp) * PSDCS2DCS(vp);
var wcsPaperPt2 = new Point3d(paperPoint2.X, paperPoint2.Y,
paperPoint1.Z).TransformBy(psdcs2wcs);
var wcsPaperPt1 = [Link](psdcs2wcs);
var vector1 = [Link](modelPoint2);
var vector2 = [Link](wcsPaperPt2);
double rotation = [Link](vector2, [Link]);
[Link] += rotation;
 var scale = [Link] / [Link];
[Link] *= scale;
[Link]();
wcsPaperPt1 = [Link](DCS2WCS(vp) * PSDCS2DCS(vp));
var wcsPaperPt2d = new Point2d(wcsPaperPt1.X, wcsPaperPt1.Y);
[Link] += new Vector2d(modelPoint1.X - wcsPaperPt2d.X,
modelPoint1.Y - wcsPaperPt2d.Y).TransformBy([Link](rotation,
wcsPaperPt2d));

[Link] = locked;
}

public Matrix3d DCS2WCS(Viewport vp)

{
return
[Link](-[Link], [Link], [Link])
*
[Link]([Link] - [Link]) *
[Link]([Link]);
}

public Matrix3d WCS2DCS(Viewport vp)

{
return DCS2WCS(vp).Inverse();
}

public static Matrix3d DCS2PSDCS(Viewport vp)

{
return
[Link]([Link], [Link]) *
[Link]([Link]()) *
[Link](new Vector3d(-[Link].X, -
[Link].Y, 0.0));
}

public Matrix3d PSDCS2DCS(Viewport vp)

{
return DCS2PSDCS(vp).Inverse();
}

public void Clayout_Manual(CTransaction Trans)

{
CPoint Poi = new CPoint();

bool Layn = true;

Point3d P3d = new Point3d();

string name = "";

List<BlockReference> LViewPort = new List<BlockReference>();

List<Polyline> Cables = new List<Polyline>();

List<BlockReference> Vecinos = new List<BlockReference>();

Point3dCollection P3dc;
 PromptPointOptions promptPointOptions = new
PromptPointOptions("Point");
PromptPointResult selectStartPoint =
[Link](promptPointOptions);
if ([Link] == [Link])
{
P3d = [Link];
}
else
{
Layn = false;
}

if (Layn)
{
PromptSelectionResult selectLinesFollow = [Link]();
if ([Link] == [Link])
{
foreach (ObjectId objectid in
[Link]())
{
DBObject entityp = [Link](objectid,
[Link]);
if (entityp is BlockReference)
{
BlockReference Br = (BlockReference)entityp;

name = [Link] ?
((BlockTableRecord)[Link]([Link])).Name :
[Link];

if (name == "Vport")
[Link](entityp as BlockReference);
}

}
}

double dist = 5000;

ObjectId ObjId = [Link]["Vport"];

BlockReference Used_Vport = new BlockReference(new Point3d(0, 0,

0), ObjId);

double NearVport = 5000;

foreach (BlockReference Pl in LViewPort)

{
//if(new Line([Link],P3d).Length < NearVport)
{
P3dc = new Point3dCollection();

DBObjectCollection DB0 = new DBObjectCollection();

[Link](DB0);

foreach (DBObject Db in DB0)

{
 if (Db is Polyline)
{
Polyline Tpol = (Polyline)Db;

Point3d Pc_Polyline_viewport =
[Link](Tpol);

if (new Line(Pc_Polyline_viewport, P3d).Length <

NearVport)
{
NearVport = new Line([Link], P3d).Length;
Used_Vport = Pl;
}
}
}
}
}

{
P3dc = new Point3dCollection();

DBObjectCollection DB0 = new DBObjectCollection();

Used_Vport.Explode(DB0);

foreach (DBObject Db in DB0)

{
if (Db is Polyline)
{
Polyline Tpol = (Polyline)Db;

for (int i = 0; i < [Link]; i++)

{
[Link](Tpol.GetPoint3dAt(i));
}

[Link](Tpol.GetPoint3dAt(0));
}
}

Polyline PLC = new Polyline();

[Link] = "0";

foreach (Point3d P in P3dc)

{
[Link]([Link], new Point2d(P.X,
P.Y), 0, 0, 0);
}

//[Link](PLC, true);

string Page = "000";

foreach (ObjectId attId in Used_Vport.AttributeCollection)

{
var acAtt = [Link](attId,
[Link]) as AttributeReference;
if ([Link] == "PAGE")
{
 Page = [Link];
// [Link](Page);
}

//[Link]([Link] + " " + [Link]);

}

Polyline VpPolyOri = new Polyline();

Polyline VpPolyDes = new Polyline();

DBObjectCollection collection = new DBObjectCollection();

Used_Vport.Explode(collection);

foreach (DBObject item in collection)

{
if (item is Polyline)
VpPolyOri = (Polyline)item;
}

Create_Layout(P3dc, Page, Trans);

}
}
else
{
Trans.End_Trans();
}
}

private void Create_Layout(Point3dCollection P3dc, string Page,

CTransaction Trans)
{
CPoint Poi = new CPoint();

int CabCon = 1;
int Hhcon = 0;
double MaxX = 0;
double MinX = 0;
double MaxY = 0;
double MinY = 0;
double MaxWidth = 0;

Polyline Space = new Polyline();

Polyline PLC = new Polyline();

Polyline VpPolyOri = PLC;

//Polyline VpPolyDes;

List<Polyline> LCable = new List<Polyline>();

Point3dCollection CableIntersectionPoint = new Point3dCollection();

foreach (Point3d P in P3dc)

[Link]([Link], new Point2d(P.X, P.Y), 0, 0,
0);
 //[Link](PLC,true);

Polyline PL05 = new Polyline();

List<BlockReference> LBR = new List<BlockReference>();

List<Polyline> Lpl = new List<Polyline>();

List<BlockReference> LVp = new List<BlockReference>();

ObjectIdCollection oidC = new ObjectIdCollection();

PromptSelectionResult selectLinesFollow =
[Link](P3dc);

if ([Link] == [Link])
{
PromptSelectionResult selectLines = [Link]();
if ([Link] == [Link])
{
foreach (ObjectId objectid in [Link]())
{
DBObject entityp = [Link](objectid,
[Link]);
if (entityp is BlockReference)
{
BlockReference Br = (BlockReference)entityp;

string name = [Link] ?

((BlockTableRecord)[Link]([Link])).Name :
[Link];

if (name == "Vport")
{
[Link](Br);
}
}
}
}

Point3d PC3d = [Link](PLC);

Point2d PC2d = new Point2d(PC3d.X, PC3d.Y);

[Link]("TILEMODE", 0);
[Link]();

LayoutManager acLayoutMgr = [Link];

if ([Link](Page))
{
[Link](Page);
}

// Create the new layout with default settings

ObjectId objID = [Link](Page);
//lo coloque yo
Layout Aclayout = [Link](objID,
[Link]) as Layout;
{
DBDictionary acPlSet =
[Link]([Link],
[Link]) as DBDictionary;
if ([Link]("11-17") == true)
{
PlotSettings plSet = [Link]("11-
17").GetObject([Link]) as PlotSettings;

[Link](plSet);
}
}
// Set the layout current if it is not already
[Link] = Page;

var vpIds = [Link]();

//configurando los viewports existentes
foreach (ObjectId vpId in vpIds)
{
var vp2 = [Link](vpId, [Link])
as Viewport;

//[Link]("Vpid = " + [Link]());

//[Link] = PC2d;
[Link] = new Point3d(10.2319, 7.7190, 0);

//[Link] = StandardScaleType.Scale1To8inchAnd1ft;
//
[Link] = 9;
[Link] = 7;

[Link] = (1.0 / 30.0);

//[Link]([Link]());

Circle C = new Circle();

[Link] = 40;
[Link] = new Point3d(PC2d.X, PC2d.Y, 0);

[Link] = PC2d;

//[Link] = new Point2d(1282, 205);

[Link] = true;
//freezing los layer dentro del viewport
ObjectIdCollection Layers = new ObjectIdCollection();
ObjectIdCollection Layers2 = new ObjectIdCollection();
LayerTable acLyrTbl;
acLyrTbl =
[Link]([Link], [Link]) as
LayerTable;
foreach (ObjectId acObjId in acLyrTbl)
{
LayerTableRecord acLyrTblRec;
acLyrTblRec = [Link](acObjId,
[Link]) as LayerTableRecord;

if ([Link] == "FST-Schematic" || [Link]

== "Vport")
{
 [Link]([Link]);
}
else
{
[Link]([Link]);
}
}
// [Link]([Link]());
// [Link]([Link]());
// [Link] = true;
}

////cover
ObjectId Obj_Id = [Link]["AT&T_COVER"];

// Insert the block into the current space

if (Obj_Id != [Link])
{
using (BlockReference Br = new BlockReference(new Point3d(9.5,
6.5, 0), Obj_Id))
{
[Link] = new Scale3d(1, 1, 1);

[Link] = "Vport2";

DynamicBlockReferencePropertyCollection DBRC =
[Link];

foreach (DynamicBlockReferenceProperty prop in DBRC)

{
if ([Link] == "PAGE")
{
[Link] = Page;
}
}

BlockTable blockTable =
[Link]([Link], [Link]) as
BlockTable;
BlockTableRecord blkTbRecPaper =
[Link](blockTable[[Link]],
[Link]) as BlockTableRecord;
[Link](Br);

BlockTableRecord Btr =
(BlockTableRecord)blockTable["AT&T_COVER"].GetObject([Link]);

foreach (ObjectId id in Btr)

{
DBObject obj = [Link]([Link]);
AttributeDefinition attDef = obj as
AttributeDefinition;
if (attDef != null && ![Link])
{
using (AttributeReference attRef = new
AttributeReference())
{
[Link](attDef,
[Link]);
 [Link] = true;

[Link](attRef);

[Link](attRef, true);

}
}
}
}
}

////datos
Obj_Id = [Link]["BURIED STAMP"];

// Insert the block into the current space

if (Obj_Id != [Link])
{
using (BlockReference Br = new BlockReference(new
Point3d(15.1306, 5.3922, 0), Obj_Id))
{
[Link] = new Scale3d(10 / 12, 10 / 12, 10 / 12);

[Link] = "Vport2";

DynamicBlockReferencePropertyCollection DBRC =
[Link];

foreach (DynamicBlockReferenceProperty prop in DBRC)

{
[Link] = Page;
}

BlockTable blockTable =
[Link]([Link], [Link]) as
BlockTable;
BlockTableRecord blkTbRecPaper =
[Link](blockTable[[Link]],
[Link]) as BlockTableRecord;
[Link](Br);

BlockTableRecord Btr = (BlockTableRecord)blockTable["BURIED

STAMP"].GetObject([Link]);

foreach (ObjectId id in Btr)

{
DBObject obj = [Link]([Link]);
AttributeDefinition attDef = obj as
AttributeDefinition;
if (attDef != null && ![Link])
{
using (AttributeReference attRef = new
AttributeReference())
{
[Link](attDef,
[Link]);
 [Link] = true;

[Link](attRef);

[Link](attRef, true);

[Link] = Page;
}
}
}
}
}

////detalles
Obj_Id = [Link]["Placement_Detail"];

// Insert the block into the current space

if (Obj_Id != [Link])
{
//using (BlockReference Br = new BlockReference(new
Point3d(16.4035, 9.4734, 0), Obj_Id))
using (BlockReference Br = new BlockReference(new
Point3d(16.2434, 10.1228, 0), Obj_Id))
{
//[Link] = new Scale3d(0.8, 0.8, 0.8);

[Link] = "Vport2";

BlockTable blockTable =
[Link]([Link], [Link]) as
BlockTable;
BlockTableRecord blkTbRecPaper =
[Link](blockTable[[Link]],
[Link]) as BlockTableRecord;
[Link](Br);

//[Link] = [Link] / 180 * 270;

BlockTableRecord Btr =
(BlockTableRecord)blockTable["Placement_Detail"].GetObject([Link]);

foreach (ObjectId id in Btr)

{
DBObject obj = [Link]([Link]);
AttributeDefinition attDef = obj as
AttributeDefinition;
if (attDef != null && ![Link])
{
using (AttributeReference attRef = new
AttributeReference())
{
[Link](attDef,
[Link]);

[Link] = true;

[Link](attRef);
[Link](attRef, true);

[Link] = "";
}
}
}
}
}

Polyline Dest = new Polyline();

//rectangulo
Obj_Id = [Link]["vPORT2"];

// Insert the block into the current space

if (Obj_Id != [Link])
{
using (BlockReference Br = new BlockReference(new
Point3d(10.2319, 7.7190, 0), Obj_Id))
{
[Link] = new Scale3d(1, 1, 1);

[Link] = "Vport2";

BlockTable blockTable =
[Link]([Link], [Link]) as
BlockTable;
BlockTableRecord blkTbRecPaper =
[Link](blockTable[[Link]],
[Link]) as BlockTableRecord;
[Link](Br);

[Link] = [Link] / 180 * 0;

BlockTableRecord Btr =
(BlockTableRecord)blockTable["vPORT2"].GetObject([Link]);

foreach (ObjectId id in Btr)

{
DBObject obj = [Link]([Link]);
AttributeDefinition attDef = obj as
AttributeDefinition;
if (attDef != null && ![Link])
{
using (AttributeReference attRef = new
AttributeReference())
{
[Link](attDef,
[Link]);

[Link] = true;

[Link](attRef);

[Link](attRef, true);
}
}
 }

DBObjectCollection dBObjectCollection = new

DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Obj in dBObjectCollection)

{
if (Obj is Polyline)
{
Dest = Obj as Polyline;
}
}
}
}
List<string> ml = new List<string>();
////polilineas
///

foreach (Polyline Pl in Lpl)

{
List<Point3d> LCorInter = new List<Point3d>();

double Max = 0;

double Min = [Link];

Point3dCollection MyCableIntersectionPoint = new

Point3dCollection();

foreach (Point3d Pd3 in CableIntersectionPoint)

{
if ([Link](Pd3, false) == Pd3)
{
if ([Link](Pd3) > Max)
Max = [Link](Pd3);
else if ([Link](Pd3) < Min)
Min = [Link](Pd3);

[Link](Pd3);
}
}

double Dc = Max - Min;

List<BlockReference> LVportVec = new List<BlockReference>();

foreach (BlockReference Br in LVp)

{
DBObjectCollection dBObjectCollection = new
DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Obj in dBObjectCollection)

{
if (Obj is Polyline)
{
 Polyline polyline = Obj as Polyline;

Point3dCollection intersectionPoints = new

Point3dCollection();
[Link](Pl,
[Link], intersectionPoints, [Link], [Link]);

if ([Link] > 0)
{
[Link](Br);
}
}
}
}

for (int i = 0; i < [Link]; i++)

{
for (int i2 = i; i2 < [Link]; i2++)
{
if
([Link]([Link](LVportVec[i].Position, false)) >
[Link]([Link](LVportVec[i2].Position, false)))
{
BlockReference Tem = LVportVec[i];
LVportVec[i] = LVportVec[i2];
LVportVec[i2] = Tem;
}
}
}

for (int i = 0; i < [Link]; i++)

{
MText mText = new MText();
[Link] = 10;
[Link] = [Link]();
[Link] = LVportVec[i].Position;
//[Link](mText, true);

foreach (ObjectId attId in

LVportVec[i].AttributeCollection)
{
var acAtt = [Link](attId,
[Link]) as AttributeReference;
if ([Link] == "PAGE")
{
//[Link]([Link]);
}
}
}

List<BlockReference> LFVportVec = new List<BlockReference>();

List<BlockReference> LFVportVecU = new List<BlockReference>();

for (int i = 0; i < [Link]; i++)

{
foreach (ObjectId attId in
LVportVec[i].AttributeCollection)
{
 var acAtt = [Link](attId,
[Link]) as AttributeReference;
if ([Link] == "PAGE")
{
if ([Link] == Page)
{
if (i > 0)
{
[Link](LVportVec[i - 1]);
}

if ([Link] > (i + 1))

{
[Link](LVportVec[i + 1]);
}
}
}
}
}

//[Link]("New Cable");

foreach (BlockReference BR in LFVportVec)

{
foreach (ObjectId attId in [Link])
{
var acAtt = [Link](attId,
[Link]) as AttributeReference;
if ([Link] == "PAGE")
{
// [Link]([Link]);
}
}
}

/* for (int i = 0; i < [Link]; i++)

{
for (int i2 = i; i2 < [Link]; i2++)
{
if([Link](CableIntersectionPoint[i]) >
[Link](CableIntersectionPoint[i2]))
{
Point3d Tem = CableIntersectionPoint[i];
CableIntersectionPoint[i] =
CableIntersectionPoint[i2];
CableIntersectionPoint[i2] = Tem;
}
}
}*/

ArrayList IntvsVport = new ArrayList();

foreach (Point3d point3D in MyCableIntersectionPoint)

{
double Dist = 1500;

string PaGe = "";

 BlockReference Tembr;

foreach (BlockReference Br in LFVportVec)

{
if ()
{
DBObjectCollection dBObjectCollection = new
DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Obj in dBObjectCollection)

{
if (Obj is Polyline)
{
Polyline polyline = Obj as Polyline;

Point3dCollection intersectionPoints = new

Point3dCollection();
[Link](Pl,
[Link], intersectionPoints, [Link], [Link]);

if ([Link] > 0)
{
foreach (Point3d P3f in
intersectionPoints)
{
if (new Line(point3D, P3f).Length <
Dist)
{
Dist = new Line(point3D,
P3f).Length;

foreach (ObjectId attId in

[Link])
{
var acAtt =
[Link](attId, [Link]) as AttributeReference;
if ([Link] == "PAGE")
{
PaGe =
[Link];

//
[Link]([Link]() + "\n" +PaGe);
}
}
}
}
}
}
}
}
}

foreach (BlockReference Br in LFVportVec)

{
if ()
{
 DBObjectCollection dBObjectCollection = new
DBObjectCollection();

[Link](dBObjectCollection);

foreach (DBObject Obj in dBObjectCollection)

{
if (Obj is Polyline)
{
Polyline polyline = Obj as Polyline;

Point3dCollection intersectionPoints = new

Point3dCollection();
[Link](Pl,
[Link], intersectionPoints, [Link], [Link]);

if ([Link] > 0)
{
foreach (Point3d P3f in
intersectionPoints)
{
if (new Line(point3D, P3f).Length
== Dist)
{
[Link](Br);

foreach (ObjectId attId in

[Link])
{
var acAtt =
[Link](attId, [Link]) as AttributeReference;
if ([Link] == "PAGE")
{

//[Link]([Link]);
}
}

}
}
}
}
}
}
}

[Link]([Link]() + "\n" + PaGe);

}
//Matchlines

foreach (Point3d P in MyCableIntersectionPoint)

{
bool Der = false;

if
([Link]([Link](Poi.Regla_3(VpPolyOri, Dest, P),
false)) < [Link](1))
 {
Der = true;

}
else if
([Link]([Link](Poi.Regla_3(VpPolyOri, Dest, P),
false)) < [Link](2))
{
Der = true;
}

string BlockName = "MatchLine";

if (Der)
BlockName = "MatchLine2";

//if ([Link](P, false) == P)

{
Obj_Id = [Link][BlockName];

// Insert the block into the current space

if (Obj_Id != [Link])
{
using (BlockReference Br = new
BlockReference(Poi.Regla_3(VpPolyOri, Dest, P), Obj_Id))
{
[Link] = "Vport2";
[Link] = new Scale3d(0.8, 0.8, 0.8);
if
([Link]([Link]([Link], false)) <
[Link](1))
{
[Link] = [Link] / 180 * 0;

//[Link] = new Point3d([Link].X,

[Link].Y + 0.1463, 0);

if ([Link].X > 13.1038)

{
[Link] = new Point3d(13.1038,
[Link].Y, 0);
}
else if ([Link].X < 7.6278)
{
[Link] = new Point3d(7.6278,
[Link].Y, 0);
}

//[Link](([Link] / [Link] *
180).ToString());

}
else if
([Link]([Link]([Link], false)) <
[Link](2))
{
[Link] = [Link] / 180 * 270;
 //[Link] = new Point3d([Link].X +
0.1463, [Link].Y, 0);

if ([Link].Y < 6.1279)

{
[Link] = new
Point3d([Link].X, 6.1279, 0);
}
else if ([Link].Y > 9.6427)
{
[Link] = new
Point3d([Link].X, 9.6427, 0);
}

//[Link](([Link] / [Link] *
180).ToString());
}
else if
([Link]([Link]([Link], false)) <
[Link](3))
{
[Link] = [Link] / 180 * 0;

//[Link] = new Point3d([Link].X,

[Link].Y - 0.1463, 0);

if ([Link].X > 13.1038)

{
[Link] = new Point3d(13.1038,
[Link].Y, 0);
}
else if ([Link].X < 7.6278)
{
[Link] = new Point3d(7.6278,
[Link].Y, 0);
}

//[Link](([Link] / [Link] *
180).ToString());
}
else
{
[Link] = [Link] / 180 * 270;

//[Link] = new Point3d([Link].X -

0.1463, [Link].Y, 0);

if ([Link].Y < 6.1279)

{
[Link] = new
Point3d([Link].X, 6.1279, 0);
}
else if ([Link].Y > 9.6427)
{
[Link] = new
Point3d([Link].X, 9.6427, 0);
}
 // [Link](([Link] / [Link] *
180).ToString());
}
string Pag = "";

foreach (string S in IntvsVport)

{
if ([Link]([Link]()))
{
Pag = [Link]('\n')[1];
}
}

if ()
{

BlockTable blockTable =
[Link]([Link], [Link]) as
BlockTable;
BlockTableRecord blkTbRecPaper =
[Link](blockTable[[Link]],
[Link]) as BlockTableRecord;
[Link](Br);

BlockTableRecord Btr =
(BlockTableRecord)blockTable[BlockName].GetObject([Link]);

foreach (ObjectId id in Btr)

{
DBObject obj =
[Link]([Link]);
AttributeDefinition attDef = obj as
AttributeDefinition;
if (attDef != null && ![Link])
{
using (AttributeReference attRef =
new AttributeReference())
{

[Link](attDef, [Link]);

[Link] = true;

[Link](attRef);

[Link](attRef, true);

if ([Link] ==
"DESCRIPTION")
{
[Link] = "SEE
PAGE# ";
}
else if ([Link] == "PAGE"
|| [Link] == "REF#")
{
[Link] = Pag;
 }
else
{
[Link] = "";
}
}
}
}

DynamicBlockReferencePropertyCollection
pcFST = [Link];

foreach (DynamicBlockReferenceProperty dP
in pcFST)
{
if ([Link] == "Flip state1")
{
/* [Link](
$"\nName: {[Link]} " +
$"Type code: {[Link]}
" +
$"Unit type: {[Link]} " +
$"Allowed values: [{[Link](",
", [Link]())}]");*/

//[Link] = "1";
}
}

bool Del = false;

foreach (ObjectId attId in

[Link])
{
var acAtt =
[Link](attId, [Link]) as AttributeReference;
if ([Link] == "PAGE")
{
if ([Link] == "")
{
Del = true;
}
}
}

if (Del)
{
[Link]();
}
[Link](Pag);
}
}
}
}
}
}
 ////set vecinos

// Get the current document and database, and start a transaction

Document acDoc = [Link];
Database acCurDb = [Link];

using (Transaction acTrans =

[Link]())
{
// Reference the Layout Manager
LayoutManager acLayoutMgr = [Link];

// Get the current layout and output its name in the Command Line
window
Layout acLayout =
[Link]([Link]([Link]),
[Link]) as Layout;

DBDictionary acPlSet =
[Link]([Link],
[Link]) as
DBDictionary;

// Check to see if the page setup exists

if ([Link]("11-17") == true)
{
PlotSettings plSet = [Link]("11-
17").GetObject([Link]) as PlotSettings;

// Update the layout

[Link]();
[Link](plSet);

// Save the new objects to the database

[Link]();
}
else
{
// Ignore the changes made
[Link]();
}
}

//Update the display*

[Link]();
//[Link]();

SpaceAlign2(PLC);
[Link] = "Model";
}

class CStreet
 {
public void AddCl(CTransaction Trans)
{
WebClient Client = new WebClient();

GeoLocationData geo =
[Link]([Link], [Link]) as
GeoLocationData;

PromptPointOptions ppo = new PromptPointOptions("First Point:");

PromptPointResult psr = [Link](ppo);
if ([Link] == [Link])
{
PromptPointOptions ppo1 = new PromptPointOptions("Second Point:");
[Link] = [Link];
[Link] = true;
PromptPointResult psr1 = [Link](ppo1);
if ([Link] == [Link])
{

List<double> X = new List<double>();

List<double> Y = new List<double>();
[Link]([Link]([Link]).X);
[Link]([Link]([Link]).X);

//[Link]([Link]([Link]).ToString());

//[Link]([Link]([Link]).ToString());
[Link]([Link]([Link]).Y);
[Link]([Link]([Link]).Y);
string LongMin = [Link]().ToString("0.000");
string LatMin = [Link]().ToString("0.000");
string LongMax = [Link]().ToString("0.000");
string LatMax = [Link]().ToString("0.000");
if ([Link](@"C:\GenXCTool\Temp Arc\[Link]"))
{
[Link](@"C:\GenXCTool\Temp Arc\[Link]");
}
[Link](@"C:\GenXCTool\Temp Arc\[Link]",
[Link]("[Link] + LongMin +
"," + LatMin + "," + LongMax + "," + LatMax));
XmlDocument XDoc = new XmlDocument();
[Link](@"C:\GenXCTool\Temp Arc\[Link]");
XmlNodeList xnNode = [Link]("node");
XmlNodeList xnWay = [Link]("way");
List<string> way = new List<string>();
string[] highway = new string[] { "motorway", "trunk",
"primary", "secondary", "tertiary", "unclassified", "residential", "road" };
bool flag = false;
bool flag0 = false;
foreach (XmlNode xWay in xnWay)
{

List<string> IdNode = new List<string>();

string Name = "";

string EOP = "";
string pre = "";
string Base = "";
 string sux = "";
string IDWAY = "";
foreach (XmlAttribute xATT in [Link])
{
if ([Link] == "id")
{
IDWAY = [Link];

}
}
flag = false;
flag0 = false;
foreach (XmlNode xWayNode in xWay)
{
if ([Link] == "nd")
{

[Link]([Link][0].Value);

}
if ([Link] == "tag")
{

if ([Link][0].Value == "highway" &&

[Link]([Link][1].Value))
{
flag = true;
if ([Link][1].Value ==
"residential")
{
EOP = "20.0";
}
}
if ([Link][0].Value ==
"tiger:name_direction_prefix")
{
pre = [Link][1].Value;

}
if ([Link][0].Value ==
"tiger:name_base")
{
Base = [Link][1].Value;

}
if ([Link][0].Value ==
"tiger:name_type")
{
sux = [Link][1].Value;

}
if (xWayNode ==
[Link][[Link] - 1])
{
flag0 = true;
}
}

if (flag && flag0)

 {
Name = (pre + " " + Base + " " + sux).ToUpper();

Polyline pl = new Polyline();

foreach (string item in IdNode)
{
foreach (XmlNode xNo in xnNode)
{
bool flag2 = false;
double lon = 0.0;
double lat = 0.0;
foreach (XmlAttribute xATT in
[Link])
{

if ([Link] == "id" && [Link] ==

item)
{
flag2 = true;

}
if (flag2)
{

if ([Link] == "lon")
{
lon =
[Link]([Link]);

}
if ([Link] == "lat")
{
lat =
[Link]([Link]);
}

}
if (flag2)
{

//[Link]([Link]()+","+[Link]());
[Link]([Link], new
Point2d([Link](new Point3d(lon, lat, 0)).X,
[Link](new Point3d(lon, lat, 0)).Y), 0, 0, 0);
}

[Link](pl, true);
[Link](pl, Name, EOP, "");

//[Link]([Link](),Name, [Link][0].Name,
[Link][0].SubLocation);
[Link] = "Streets";
 }

}
}
}
}