public void LoadHpglGengraveNoParamAndSpeed()
{
var loadInfo = new LoadOptions
{
LoadType = LoadOptions.ELoadType.Hpgl,
AutoScale = false,
PenMoveType = LoadOptions.PenType.ZMove,
EngravePosInParameter = false,
EngravePosUp = 1.23m,
EngravePosDown = 0.12m,
EngraveDownSpeed = 123,
MoveSpeed = 499,
FileContent = Encoding.ASCII.GetBytes("IN;PU0,0;PD400,400;PD800,400")
};
var load = LoadBase.Create(loadInfo);
load.Load();
string[] gcode =
{
"G1 F499", "G0 Z1.23", "G0 X0 Y0", "G1 Z0.12 F123", "G1 X10 Y10 F499", "G1 X20 Y10", "G0 Z1.23"
};
var list = load.Commands.Where(e => e is G00Command || e is G01Command);
CheckGCode(list, gcode);
}
private static LoadBase CallLoadWithContent(LoadOptions opt)
{
var filename = opt.FileName;
var fileContent = opt.FileContent;
string pathFileName = Path.GetFileName(filename);
string tmpFile = Path.GetTempPath() + pathFileName;
opt.FileName = tmpFile;
opt.ImageWriteToFileName = null;
try
{
File.WriteAllBytes(tmpFile, fileContent);
LoadBase load = LoadBase.Create(opt);
if (load == null)
{
return(null);
}
load.Load();
return(load);
}
finally
{
File.Delete(tmpFile);
}
}
public void LoadHPGLGengraveParam()
{
var loadinfo = new LoadOptions
{
LoadType = LoadOptions.ELoadType.HPGL,
AutoScale = false,
PenMoveType = LoadOptions.PenType.ZMove,
EngravePosInParameter = true,
FileContent = Encoding.ASCII.GetBytes("IN;PU0,0;PD400,400")
};
var load = LoadBase.Create(loadinfo);
load.Load();
string[] gcode =
{
"G1 F500",
"G0 Z#1",
"G0 X0 Y0",
"G1 Z#2",
"G1 X10 Y10",
"G0 Z#1"
};
var list = load.Commands.Where(e => e is G00Command || e is G01Command);
CheckGCode(list, gcode);
}
public void LoadHpglConvertOpenLine()
{
var loadInfo = new LoadOptions
{
LoadType = LoadOptions.ELoadType.Hpgl,
AutoScale = false,
PenMoveType = LoadOptions.PenType.CommandString,
MoveSpeed = 499,
ConvertType = LoadOptions.ConvertTypeEnum.InvertLineSequence,
FileContent = Encoding.ASCII.GetBytes("IN;PU0,0;PD400,400;PD800,400;PU800,800;PD1200,1200;PU;SP0;PU0,0")
};
var load = LoadBase.Create(loadInfo);
load.Load();
string[] gcode =
{
"G1 F499", "M107", "G0 X0 Y0", "M106 S255", "G1 X10 Y10", "G1 X20 Y10", "M107", "G0 X20 Y20", "M106", "G1 X30 Y30", "M107", "M5" // ShutdownCommands
};
var list = load.Commands.Where(IsGCommand);
CheckGCode(list, gcode);
}
private void LoadLocal(LoadOptions loadInfo)
{
try
{
LoadBase load = LoadBase.Create(loadInfo);
load.LoadOptions = loadInfo;
load.Load();
Commands.Clear();
Commands.AddRange(load.Commands);
if (!string.IsNullOrEmpty(loadInfo.GCodeWriteToFileName))
{
string gcodeFileName = Environment.ExpandEnvironmentVariables(loadInfo.GCodeWriteToFileName);
using (var sw = File.CreateText(gcodeFileName))
{
load.WriteGCodeFile(sw);
}
using (var sw = File.CreateText(Path.GetDirectoryName(gcodeFileName) + @"\" + Path.GetFileNameWithoutExtension(gcodeFileName) + @".cb"))
{
load.WriteCamBamFile(sw);
}
using (var sw = File.CreateText(Path.GetDirectoryName(gcodeFileName) + @"\" + Path.GetFileNameWithoutExtension(gcodeFileName) + @".hpgl"))
{
load.WriteImportInfoFile(sw);
}
}
}
catch (Exception)
{
throw;
}
}
public void LoadHPGLLaser()
{
var loadinfo = new LoadOptions
{
LoadType = LoadOptions.ELoadType.HPGL,
AutoScale = false,
PenMoveType = LoadOptions.PenType.CommandString,
MoveSpeed = 499,
FileContent = Encoding.ASCII.GetBytes("IN;PU0,0;PD400,400;PD800,400;PU800,800;PD1200,1200")
};
var load = LoadBase.Create(loadinfo);
load.Load();
string[] gcode =
{
"G1 F499",
"M107",
"G0 X0 Y0",
"M106 S255",
"G1 X10 Y10",
"G1 X20 Y10",
"M107",
"G0 X20 Y20",
"M106",
"G1 X30 Y30",
"M107",
"M5" // ShutdownCommands
};
var list = load.Commands.Where(e => IsGCommand(e));
CheckGCode(list, gcode);
}
IEnumerator request()
{
if (currentLoaderTask.type == LoadType.Get ||
currentLoaderTask.type == LoadType.LocalOther)
{
targetLoad = new HttpLoad(currentLoaderTask.url);
}
else if (currentLoaderTask.type == LoadType.LocalAB)
{
targetLoad = new BundleLoadAsync(currentLoaderTask.url);
}
else if (currentLoaderTask.type == LoadType.Post)
{
targetLoad = new HttpLoad(currentLoaderTask.url, currentLoaderTask.wform);
}
else if (currentLoaderTask.type == LoadType.PostWithHeader)
{
targetLoad = new HttpLoad(currentLoaderTask.url, currentLoaderTask.postdata, currentLoaderTask.header);
}
yield return(targetLoad.Load().coroutine);
reponseData = new ResponseData(targetLoad);
currentLoaderTask.SetResponseData(reponseData);
idleCallback(this);
state = State.Idle;
}
public static LoadBase CallLoad(string filename, byte[] filecontent, LoadOptions opt)
{
string pathfilename = Path.GetFileName(filename);
string tmpfile = Path.GetTempPath() + pathfilename;
opt.FileName = tmpfile;
opt.ImageWriteToFileName = null;
try
{
File.WriteAllBytes(tmpfile, filecontent);
LoadBase load = LoadBase.Create(opt);
if (load == null)
{
return(null);
}
load.Load();
return(load);
}
finally
{
File.Delete(tmpfile);
}
}
public void LoadHpglConvertClosedLine()
{
var loadInfo = new LoadOptions
{
LoadType = LoadOptions.ELoadType.Hpgl,
AutoScale = false,
PenMoveType = LoadOptions.PenType.CommandString,
MoveSpeed = 499,
CutterSize = 0,
ConvertType = LoadOptions.ConvertTypeEnum.InvertLineSequence,
FileContent = Encoding.ASCII.GetBytes(
"IN;" + "PU0,0;PD0,400,400,400,400,0,0,0;" + "PU50,50;PD350,50,350,350,50,350,50,50;" + "PU100,100;PD300,100,300,300,100,300,100,100;" +
"PU150,150;PD250,150,250,250,150,250,150,150;" + "PU;SP0")
};
var load = LoadBase.Create(loadInfo);
load.Load();
string[] gcode =
{
"G1 F499", "M107", "G0 X3.75 Y3.75", "M106 S255", "G1 X6.25 Y3.75", "G1 X6.25 Y6.25", "G1 X3.75 Y6.25", "G1 X3.75 Y3.75", "M107", "G0 X2.5 Y2.5", "M106", "G1 X7.5 Y2.5",
"G1 X7.5 Y7.5", "G1 X2.5 Y7.5", "G1 X2.5 Y2.5", "M107", "G0 X1.25 Y1.25", "M106", "G1 X8.75 Y1.25", "G1 X8.75 Y8.75", "G1 X1.25 Y8.75", "G1 X1.25 Y1.25", "M107", "G0 X0 Y0", "M106",
"G1 X0 Y10", "G1 X10 Y10", "G1 X10 Y0", "G1 X0 Y0", "M107", "M5"
};
var list = load.Commands.Where(IsGCommand);
CheckGCode(list, gcode);
}
IEnumerator request()
{
if (currentLoaderTask.type == LoadType.Get || currentLoaderTask.type == LoadType.LocalOther)
{
targetLoad = new HttpLoad(currentLoaderTask.url, false);
}
else if (currentLoaderTask.type == LoadType.LocalAB)
{
targetLoad = new BundleLoadAsync(currentLoaderTask.url);
}
else if (currentLoaderTask.type == LoadType.StreamAssets)
{
targetLoad = new HttpLoad(currentLoaderTask.url, "");
}
else if (currentLoaderTask.type == LoadType.Post)
{
targetLoad = new HttpLoad(currentLoaderTask.url, currentLoaderTask.wform);
}
else if (currentLoaderTask.type == LoadType.PostWithHeader)
{
targetLoad = new HttpLoad(currentLoaderTask.url, currentLoaderTask.postdata, currentLoaderTask.header);
}
//HgqTest.AddUrlDown(currentLoaderTask.url);
yield return(targetLoad.Load().coroutine);
//HgqTest.EndUrlDown(currentLoaderTask.url);
reponseData = new ResponseData(targetLoad);
currentLoaderTask.SetResponseData(reponseData);
idleCallback(this);
//targetLoad.Dispose();
state = State.Idle;
}
public void LoadHpglSkipPU()
{
var loadInfo = new LoadOptions
{
LoadType = LoadOptions.ELoadType.Hpgl,
AutoScale = false,
PenMoveType = LoadOptions.PenType.CommandString,
MoveSpeed = 499,
FileContent = Encoding.ASCII.GetBytes("IN;PU1000,100;PU0,0;PD400,400;PU0,0")
// leading PU1000,100 and trailing PU0,0 is skipped
};
var load = LoadBase.Create(loadInfo);
load.Load();
string[] gcode =
{
"G1 F499", "M107", "G0 X0 Y0", "M106 S255", "G1 X10 Y10", "M107", "M5" // ShutdownCommands
};
var list = load.Commands.Where(IsGCommand);
CheckGCode(list, gcode);
}
void DisposeLoader()
{
if (targetLoad != null)
{
targetLoad.Dispose();
targetLoad = null;
}
}
private static void WriteCamBamFile(LoadBase load, string filename)
{
using (TextWriter writer = new StreamWriter(Environment.ExpandEnvironmentVariables(filename)))
{
var x = new XmlSerializer(typeof(CamBam.CamBam));
x.Serialize(writer, load.CamBam);
}
}
public ResponseData(LoadBase load)
{
isWWW = load.isWWW;
bytes = load.bytes;
ab = load.ab;
url = load.url;
text = load.text;
texture = load.texture;
success = load.success;
error = load.error;
}
private static LoadBase CallLoadWithFileName(LoadOptions opt)
{
LoadBase load = LoadBase.Create(opt);
if (load == null)
{
return(null);
}
load.Load();
return(load);
}
public static void WriteImportInfoFile(this LoadBase load, StreamWriter writer)
{
if (load.Commands.Exists(c => !string.IsNullOrEmpty(c.ImportInfo)))
{
load.Commands.ForEach(
c =>
{
if (!string.IsNullOrEmpty(c.ImportInfo))
{
writer.WriteLine(c.ImportInfo);
}
});
}
}
private void WriteImportInfoFile(LoadBase load, string filename)
{
if (Commands.Exists(c => !string.IsNullOrEmpty(c.ImportInfo)))
{
using (TextWriter writer = new StreamWriter(Environment.ExpandEnvironmentVariables(filename)))
{
Commands.ForEach(c => { if (!string.IsNullOrEmpty(c.ImportInfo))
{
writer.WriteLine(c.ImportInfo);
}
});
}
}
}
public static void WriteGCodeFile(this LoadBase load, StreamWriter sw)
{
Command last = null;
var state = new CommandState();
foreach (var r in load.Commands)
{
string[] cmds = r.GetGCodeCommands(last?.CalculatedEndPosition, state);
if (cmds != null)
{
foreach (string str in cmds)
{
sw.WriteLine(str);
}
}
last = r;
}
}
public void LoadHPGL00()
{
var loadinfo = new LoadOptions
{
LoadType = LoadOptions.ELoadType.HPGL,
AutoScale = false,
FileContent = Encoding.ASCII.GetBytes("IN;PU0,0")
};
var load = LoadBase.Create(loadinfo);
load.Load();
var list = load.Commands.Where(e => e is G00Command || e is G01Command);
list.Count().Should().Be(2);
list.First().Should().BeOfType <G01Command>(); // G0 F500
list.ElementAt(1).Should().BeOfType <G00Command>(); // G0 z1
//list.ElementAt(2).Should().BeOfType<G00Command>(); // G0 0,0 => PU0,0, is skipped by new version
}
public static System.Collections.Generic.List <string> GenerateResourceIdsForTableName(Element element, BuiltInCategory categoryId)
{
System.Collections.Generic.List <string> list = new System.Collections.Generic.List <string>();
ElementTypeEnum elementTypeEnum = (element is ElementType) ? ElementTypeEnum.SYMBOL : ElementTypeEnum.INSTANCE;
list.Add(string.Format("TabN_{0}_{1}", categoryId, elementTypeEnum));
BuiltInCategory builtInCategory = (BuiltInCategory)(-1);
bool flag = false;
FamilyInstance familyInstance = element as FamilyInstance;
if (familyInstance != null && familyInstance.Host != null)
{
builtInCategory = APIObjectList.GetCategoryId(familyInstance.Host);
flag = true;
}
else
{
LoadBase loadBase = element as LoadBase;
if (loadBase != null && loadBase.HostElement != null)
{
builtInCategory = APIObjectList.GetCategoryId(loadBase.HostElement);
flag = true;
}
else
{
Opening opening = element as Opening;
if (opening != null && opening.Host != null)
{
builtInCategory = APIObjectList.GetCategoryId(opening.Host);
list.Add(string.Format("TabN_{0}_{1}", "OST_Type_Opening", builtInCategory));
list.Add("TabN_Type_" + opening.GetType().FullName.Replace('.', '_'));
}
else
{
Rebar rebar = element as Rebar;
if (rebar != null && rebar.GetHostId() != ElementId.InvalidElementId)
{
builtInCategory = APIObjectList.GetCategoryId(rebar.GetHostId(), rebar.Document);
flag = true;
}
}
}
}
if (flag)
{
list.Add(string.Format("TabN_{0}_{1}", categoryId, builtInCategory));
}
if (element is RoomTag)
{
list.Add("TabN_Type_" + element.GetType().FullName.Replace('.', '_'));
}
if (element != null && element.Id.IntegerValue != -1)
{
if (element.LevelId != ElementId.InvalidElementId)
{
list.Add("TabN_CST_ElementLevel");
}
if (element.CreatedPhaseId != ElementId.InvalidElementId)
{
list.Add("TabN_CST_ElementPhase");
}
}
return(list);
}
private void Stream( ArrayList data, LoadBase loadbase )
{
// Works only for Revit Structure!!
data.Add( new Snoop.Data.ClassSeparator( typeof( LoadBase ) ) );
data.Add( new Snoop.Data.Object( "Host element", loadbase.HostElement ) );
data.Add( new Snoop.Data.String( "Load case name", loadbase.LoadCaseName ) );
data.Add( new Snoop.Data.String( "Load category name", loadbase.LoadCategoryName ) );
data.Add( new Snoop.Data.String( "Load nature name", loadbase.LoadNatureName ) );
AreaLoad areaload = loadbase as AreaLoad;
if( areaload != null )
{
Stream( data, areaload );
return;
}
LineLoad lineload = loadbase as LineLoad;
if( lineload != null )
{
Stream( data, lineload );
return;
}
PointLoad pointload = loadbase as PointLoad;
if( pointload != null )
{
Stream( data, pointload );
return;
}
}
public static void WriteCamBamFile(this LoadBase load, StreamWriter writer)
{
var x = new XmlSerializer(typeof(CamBam.CamBam));
x.Serialize(writer, load.CamBam);
}
