internal void Read(ParameterReader paramReader)
{
while (paramReader.Read())
{
switch (paramReader.HeadToken)
{
case "id_start":
{
var light = new Light {
Id = ( LightId )paramReader.ReadInt32()
};
{
light.Read(paramReader);
}
Lights.Add(light);
break;
}
case "group_start":
throw new InvalidDataException("Expected group end before group start");
case "group_end":
if (paramReader.ReadUInt32() != Id)
{
throw new InvalidDataException($"Expected group end with id {Id}");
}
return;
}
}
}
/// <summary>
/// Reads required connections pamareters from stored file
/// </summary>
private void ReadConnectionParameters()
{
// Read parameters from given file
var parameters = ParameterReader.ReadParamters("FxcmParams.xml", "Fxcm");
if (parameters.Count == 5)
{
string loginId;
parameters.TryGetValue("Login", out loginId);
string password;
parameters.TryGetValue("Password", out password);
string account;
parameters.TryGetValue("Account", out account);
string connection;
parameters.TryGetValue("Connection", out connection);
string url;
parameters.TryGetValue("Url", out url);
// Create new object
_connectionParameters = new ConnectionParameters(loginId, password, account, connection, url);
return;
}
_connectionParameters = null;
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var id1 = reader.ReadInt("imageId1");
var id2 = reader.ReadInt("imageId2");
reader.ExpectNoMoreArgs();
if (id1 < 0 || id1 >= model.Images.NumImages)
{
throw new Exception("imageId1 out of range");
}
if (id2 < 0 || id2 >= model.Images.NumImages)
{
throw new Exception("imageId2 out of range");
}
var ssim = model.SSIM.GetStats(model.Images.Images[id1].Image, model.Images.Images[id2].Image,
LayerMipmapRange.MostDetailed);
Console.Error.Write("luminance:\t");
Console.Out.WriteLine(ssim.Luminance);
Console.Error.Write("contrast:\t");
Console.Out.WriteLine(ssim.Contrast);
Console.Error.Write("structure:\t");
Console.Out.WriteLine(ssim.Structure);
Console.Error.Write("ssim:\t\t");
Console.Out.WriteLine(ssim.SSIM);
Console.Error.Write("dssim:\t\t");
Console.Out.WriteLine(ssim.DSSIM);
}
/// <summary>
/// Reads required connections pamareters from stored file
/// </summary>
private void ReadConnectionParameters()
{
// Read parameters from given file
var parameters = ParameterReader.ReadParamters("IqFeedParams.xml", "IqFeed");
if (parameters.Count == 4)
{
string loginId;
parameters.TryGetValue("LoginID", out loginId);
string password;
parameters.TryGetValue("Password", out password);
string productionId;
parameters.TryGetValue("ProductID", out productionId);
string productVersion;
parameters.TryGetValue("ProductVersion", out productVersion);
// Create new object
_connectionParameters = new ConnectionParameters(loginId, password, productionId, productVersion);
return;
}
_connectionParameters = null;
}
public override void Read(EndianBinaryReader reader, ISection section = null)
{
var paramReader = new ParameterReader(reader);
while (paramReader.Read())
{
switch (paramReader.HeadToken)
{
case "offset":
Offset = paramReader.ReadSingle();
break;
case "scale":
Scale = paramReader.ReadSingle();
break;
case "position":
Position = paramReader.ReadVector3();
break;
case "direction":
Direction = paramReader.ReadVector3();
break;
}
}
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var idx = reader.ReadInt("index");
reader.ExpectNoMoreArgs();
var filter = model.Filter.Filter[idx];
foreach (var fp in filter.Parameters)
{
Console.Out.Write($"{fp.GetBase().Name} ");
switch (fp.GetParamterType())
{
case ParameterType.Float:
Console.Out.WriteLine(fp.GetFloatModel().Value);
break;
case ParameterType.Int:
Console.Out.WriteLine(fp.GetIntModel().Value);
break;
case ParameterType.Bool:
Console.Out.WriteLine(fp.GetBoolModel().Value);
break;
}
}
foreach (var tp in filter.TextureParameters)
{
Console.Out.WriteLine($"{tp.Name}: (image) {tp.Source}");
}
Console.Out.WriteLine(); // signal params end
}
private static void addParameter(Instruction instruction, int childIndex, ParameterReader paramData, GameObject parent)
{
string type = paramData.readWord().ToLower();
if (type.Equals("boolean"))
{
BooleanParameter boolean = (BooleanParameter)instruction.addBooleanChild();
boolean.Valeur = paramData.readBoolean();
}
else if (type.Equals("integer"))
{
IntegerParameter integer = (IntegerParameter)instruction.addIntegerChild();
integer.Valeur = paramData.readInt();
if (paramData.hasNextWord())
{
addIntegerMethod(integer, paramData.readWord(), instruction.gameObject);
}
if (paramData.hasNextWord())
{
integer.autoCompile = paramData.readBoolean();
}
}
else
{
Debug.LogError("MAPLOADER - ERROR : Unknown parameter type for " + type);
}
}
public static Instruction createInstruction(string line, float x, float y, GameObject parent, Dictionary <string, ParameterReader> parameters)
{
line = line.Replace('_', ' ');
Instruction instruction = createInstructionObject(parent, line, x, y);
int indexOfArgument = line.IndexOf('$');
int indexOfWhereImAt = 0;
int indexOfChild = 0;
while (indexOfArgument != -1)
{
string argumentKey = line.Substring(indexOfArgument, 3);
if (parameters.ContainsKey(argumentKey))
{
ParameterReader paramReader = parameters[argumentKey];
addParameter(instruction, indexOfChild++, paramReader, parent);
paramReader.reset();
}
else
{
Debug.LogError("Unknown parameter key\"" + argumentKey + "\"");
}
indexOfWhereImAt += indexOfArgument + 1;
indexOfArgument = line.IndexOf('$', indexOfArgument + 1);
}
if (instruction.hasCompileSpot)
{
string compileKey = line.Substring(line.IndexOf("¶"));
addCompileSpotMethod(instruction, compileKey, parameters);
}
instruction.refresh();
return(instruction);
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var mode = reader.ReadEnum <StatMode>("min/max/avg", StatMode.avg);
var type = reader.ReadEnum <StatType>("luminance/luma/avg/lightness", StatType.avg);
reader.ExpectNoMoreArgs();
model.Apply();
var stats = model.GetStatistics(model.Pipelines[0].Image);
switch (type)
{
case StatType.luminance:
Print(stats.Luminance, mode);
break;
case StatType.luma:
Print(stats.Luma, mode);
break;
case StatType.avg:
Print(stats.Average, mode);
break;
case StatType.lightness:
Print(stats.Lightness, mode);
break;
default: throw new Exception("unknown type " + type);
}
}
public override void Read(EndianBinaryReader reader, ISection section = null)
{
var paramReader = new ParameterReader(reader);
while (paramReader.Read())
{
switch (paramReader.HeadToken)
{
case "scale":
Scale = paramReader.ReadSingle();
break;
case "cycle":
Cycle = paramReader.ReadSingle();
break;
case "rot":
Rotation = paramReader.ReadVector2();
break;
case "bias":
Bias = paramReader.ReadSingle();
break;
case "spc":
Spc[paramReader.ReadInt32()] = paramReader.ReadVector2();
break;
}
}
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
reader.ExpectNoMoreArgs();
program.Close = true;
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
reader.ExpectNoMoreArgs();
Console.Out.WriteLine(model.Images.NumMipmaps);
}
private void readParam(string line)
{
BufferedDataReader parser = new BufferedDataReader(line, "");
string key = parser.readWord();
ParameterReader lineParam = new ParameterReader(key, parser.remainingLine, this.fileLine);
this.parameterReaders.Add(key, lineParam);
}
public override void Read(EndianBinaryReader reader, ISection section = null)
{
var paramReader = new ParameterReader(reader);
while (paramReader.Read())
{
switch (paramReader.HeadToken)
{
case "exposure":
Exposure = paramReader.ReadSingle();
break;
case "gamma":
Gamma = paramReader.ReadSingle();
break;
case "saturate_power":
SaturatePower = paramReader.ReadUInt32();
break;
case "saturate_coef":
SaturateCoefficient = paramReader.ReadSingle();
break;
case "flare":
FlarePower = paramReader.ReadSingle();
FlareShaft = paramReader.ReadSingle();
FlareGhost = paramReader.ReadSingle();
break;
case "sigma":
GlareRadius = paramReader.ReadVector3();
break;
case "intensity":
GlareIntensity = paramReader.ReadVector3();
break;
case "auto_exposure":
AutoExposure = paramReader.ReadBoolean();
break;
case "tone_map_type":
ToneMapType = ( ToneMapType )paramReader.ReadInt32();
break;
case "fade_color":
FadeColor = paramReader.ReadVector3();
FadeBlendFunc = ( FadeBlendFunc )paramReader.ReadInt32();
break;
case "tone_transform":
ToneTransStart = paramReader.ReadVector3();
ToneTransEnd = paramReader.ReadVector3();
break;
}
}
}
public TradierOrderExecutionProvider()
{
_parameterReader = new ParameterReader("TradierOrderParams.xml");
_tradierManager = new TradierManager(_parameterReader.GetParameterValue("Account"),
_parameterReader.GetParameterValue("Token"), _parameterReader.GetParameterValue("BaseUrl"));
InitializeTimer();
InitializeLogger();
_ordersMap = new ConcurrentDictionary <string, Order>();
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var layer = reader.ReadInt("layer");
reader.ExpectNoMoreArgs();
export.Layer = layer;
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var q = reader.ReadInt("quality");
reader.ExpectNoMoreArgs();
model.Export.Quality = q;
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var mip = reader.ReadInt("mipmap");
reader.ExpectNoMoreArgs();
export.Mipmap = mip;
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var mip = reader.ReadInt("mipmapIndex", 0);
reader.ExpectNoMoreArgs();
Console.Out.WriteLine(model.Images.GetWidth(mip));
Console.Out.WriteLine(model.Images.GetHeight(mip));
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var idx1 = reader.ReadInt("oldIndex");
var idx2 = reader.ReadInt("newIndex");
reader.ExpectNoMoreArgs();
model.Images.MoveImage(idx1, idx2);
}
private void Test <T>(T parameter, String[] keys, String[] expected)
{
var parsed = new List <String>();
foreach (var key in keys)
{
parsed.AddRange(ParameterReader <T> .GetValues(parameter, key));
}
AssertSameValues(expected, parsed.ToArray());
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
reader.ExpectNoMoreArgs();
if (model.Images.NumMipmaps > 1)
{
model.Images.DeleteMipmaps();
}
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
reader.ExpectNoMoreArgs();
model.Apply();
var stats = model.Stats.GetStatisticsFor(model.Pipelines[0].Image);
Console.Out.WriteLine(stats.HasAlpha);
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
reader.ExpectNoMoreArgs();
for (var index = 0; index < model.Filter.Filter.Count; index++)
{
var filterModel = model.Filter.Filter[index];
Console.Out.WriteLine($"{index}: {filterModel.Name}");
Console.Out.WriteLine(filterModel.Description);
}
}
static void addCompileSpotMethod(Instruction instruction, string compileKey, Dictionary <string, ParameterReader> parameters)
{
instruction.addCompileSpot();
if (parameters.ContainsKey(compileKey))
{
ParameterReader reader = parameters[compileKey];
addCompileSpotMethod(instruction, reader);
reader.reset();
}
else
{
Debug.LogError("MAPLOADER - ERROR : Unknown Key " + compileKey);
}
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var color = reader.ReadString("image equation");
var hasAlpha = reader.HasMoreArgs();
var alpha = reader.ReadString("alpha equation", "");
reader.ExpectNoMoreArgs();
model.Pipelines[0].Color.Formula = color;
if (hasAlpha)
{
model.Pipelines[0].Alpha.Formula = alpha;
}
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
if (reader.HasMoreArgs())
{
var idx = reader.ReadInt("index");
reader.ExpectNoMoreArgs();
model.Filter.DeleteFilter(idx);
}
else
{
// delete all
model.Filter.SetFilter(new List <FilterModel>());
}
}
public override ViewModels.Announcement.Notification Read(long id)
{
var viewModel = base.Read(id);
var documents = new List <DocumentHandle>();
viewModel.FolderHandle = new FolderHandle()
{
isEmpty = true,
isLoading = false,
itemParameterName = "notificationFolderId",
tempFolderId = 0,
};
if (viewModel.Folder > 0)
{
var tempDocumentTypeId = ParameterReader.ReadSystemParameter <long>("TempDocumentType");
viewModel.FolderHandle.folderId = viewModel.Folder;
var documentList = _folderService.ListDocuments(viewModel.FolderHandle.folderId.Value);
if (documentList.Count() > 0)
{
viewModel.FolderHandle.isEmpty = false;
foreach (var document in documentList)
{
if (document.DocumentType != tempDocumentTypeId)
{
var documentHandle = new DocumentHandle
{
documentId = document.DocumentId,
fileName = document.Name,
isEmpty = false,
isLoading = false,
itemId = id,
itemParameterName = "notificationFolderId",
tempDocumentId = 0
};
documents.Add(documentHandle);
}
}
}
}
viewModel.FolderHandle.documents = documents;
return(viewModel);
}
public override void Execute(List <string> arguments, Models model)
{
var reader = new ParameterReader(arguments);
var x = reader.ReadInt("x");
var y = reader.ReadInt("y");
var layer = reader.ReadInt("layer", 0);
var mipmap = reader.ReadInt("mipmap", 0);
var radius = reader.ReadInt("radius", 0);
reader.ExpectNoMoreArgs();
model.Apply();
var color = model.GetPixelValue(model.Pipelines[0].Image, new Size3(x, y, 0), new LayerMipmapSlice(layer, mipmap), radius);
Console.Out.WriteLine(color.ToDecimalString(true, 5));
color = color.ToSrgb();
Console.Out.WriteLine(color.ToBitString(true));
}
public bool GetLegalAddress(PaymentMethodDto paymentMethodDto)
{
try
{
var getLegalAddressValue = ParameterReader.GetParameterByName(paymentMethodDto, GetLegalAddressParameter).Value;
bool getLegalAddress;
if (bool.TryParse(getLegalAddressValue, out getLegalAddress))
{
return(getLegalAddress);
}
_log.Warn("Could not convert parameter value for GetLegalAddress to a boolean and is therefor handled as false.");
}
catch (ArgumentNullException)
{
return(false);
}
return(false);
}
