public OutputData DoAction(IInputData input)
{
HttpRequest request = WebGlobalVariable.Request;
IFormFileCollection fileCollection = request.ReadFormAsync().GetAwaiter().GetResult().Files;
IFormFile file = fileCollection["Filedata"];
if (file?.Length > 0 && !string.IsNullOrEmpty(file?.FileName))
{
AliyunOSSUploadInfo upload = new AliyunOSSUploadInfo(file);
try
{
using (MemoryStream stream = new MemoryStream(upload.FileSize))
{
file.CopyTo(stream);
var metaData = AliyunOSSUtil.CreateMetaData(file);
stream.Flush();
stream.Position = 0;
upload.TempFile.UploadFile(stream, metaData);
return(OutputData.CreateToolkitObject(new WebUploadResult(upload)));
}
}
catch (Exception ex)
{
return(OutputData.CreateToolkitObject(new WebErrorResult(ex.Message)));
}
}
return(OutputData.CreateToolkitObject(new WebErrorResult("没有上传文件")));
}
public async Task <Responce> PostAsync([FromBody] InputData input)
{
return(await Task.Run(() =>
{
try
{
// Проверка аргумента на null
_ = input ?? throw new ArgumentNullException(nameof(input));
// Решение задачи
IBalanceSolver solver = new AccordBalanceSolver();
var output = new OutputData
{
X = solver.Solve(input.X0, input.A, input.B, input.Measurability,
input.Tolerance, input.Lower, input.Upper),
DisbalanceOriginal = solver.DisbalanceOriginal,
Disbalance = solver.Disbalance
};
return new Responce
{
Type = "result",
Data = output
};
}
catch (Exception e)
{
return new Responce
{
Type = "error",
Data = e.Message
};
}
}));
}
public void Init(IStreamHost host)
{
this.host = host;
this.image = host.CreateInputStream<ImageStream>("Stream In");
this.width = host.CreateOutput<int>("Output 1");
}
public override object ShowViewDialog(IViewController owner)
{
IEnumerable <ChartInfo> charts = null;
View.ShowDialog(owner.View);
if (selectedOption != ChartOption.NoCharts)
{
var data = OutputData.GetData(inputFilePath);
if (selectedOption == ChartOption.DefaultCharts)
{
charts = buildDefaultCharts(data);
}
else if (selectedOption == ChartOption.CustomCharts)
{
using (var custom = new CustomChartsController(data, Path.ChangeExtension(inputFilePath, Strings.GraphTemplateFileExtension)))
{
charts = custom.ShowViewDialog(this) as IEnumerable <ChartInfo>;
}
if (charts != null && charts.Any())
{
GraphTemplateStream.Write(Path.ChangeExtension(inputFilePath, Strings.GraphTemplateFileExtension), charts);
}
}
}
return(charts);
}
public override OutputData DoAction(IInputData input)
{
if (input.IsPost)
{
using (PartFuncResolver func = new PartFuncResolver(this)
{
UpdateMode = UpdateMode.DelIns
})
using (PartSubFuncResolver subFunc = new PartSubFuncResolver(this)
{
UpdateMode = UpdateMode.DelIns
})
{
string partId = input.QueryString["Id"];
DataSet postDataSet = input.PostObject.Convert <DataSet>();
func.SelectWithParam("PartId", partId);
subFunc.SelectWithParam("PartId", partId);
func.Update(postDataSet, input);
subFunc.Update(postDataSet, input);
UpdateUtil.UpdateTableResolvers(Context, (Action <Transaction>)null, func, subFunc);
return(OutputData.CreateToolkitObject(KeyData.Empty));
}
}
TkDebug.ThrowImpossibleCode(this);
return(null);
}
public IActionResult CreateTicket(int count, int hours, int minutes, int seconds)
{
var hasil = new OutputData()
{
IsSucceed = true
};
try
{
var listTicket = new List <Ticket>();
foreach (var i in Enumerable.Range(0, count))
{
var item = Ticket.GenerateTicket(hours, minutes, seconds);
item.Id = db.GetSequence <Ticket>();
db.InsertData <Ticket>(item);
readyTickets.Enqueue(item);
}
}
catch
{
hasil.IsSucceed = false;
}
return(Ok(hasil));
}
public override OutputData DoAction(IInputData input)
{
if (input.Style.Style == PageStyle.Update)
{
if (input.IsPost)
{
try
{
return(fSource.Update(input, input.PostObject));
}
catch (WebPostException ex)
{
return(OutputData.CreateToolkitObject(ex.CreateErrorResult()));
}
}
else
{
return(DoDetailAction(input));
}
}
else
{
return(ErrorPageStyle(PageStyle.Update, input));
};
}
private int outputLength = 0; // Replace data[0].output.length
// Use this for initialization
void Start()
{
InputData trainingInput = new InputData();
OutputData trainingOutput = new OutputData();
string[] inputKeys = { "rouge", "vert", "bleu" };
string[] outputKeys = { "rouge", "vert", "bleu", "jaune", "cyan", "rose", "blanc" };
trainingInput.Add(inputKeys, new double[] { 255, 0, 0 });
trainingOutput.Add(outputKeys, new double[] { 1, 0, 0, 0, 0, 0, 0.3 });
trainingInput.Add(inputKeys, new double[] { 0, 255, 0 });
trainingOutput.Add(outputKeys, new double[] { 0, 1, 0, 0, 0, 0, 0.3 });
trainingInput.Add(inputKeys, new double[] { 0, 0, 255 });
trainingOutput.Add(outputKeys, new double[] { 0, 0, 1, 0, 0, 0, 0.3 });
trainingInput.Add(inputKeys, new double[] { 255, 255, 0 });
trainingOutput.Add(outputKeys, new double[] { 0, 0, 0, 1, 0, 0, 0.6 });
trainingInput.Add(inputKeys, new double[] { 0, 255, 255 });
trainingOutput.Add(outputKeys, new double[] { 0, 0, 0, 0, 1, 0, 0.6 });
trainingInput.Add(inputKeys, new double[] { 255, 0, 255 });
trainingOutput.Add(outputKeys, new double[] { 0, 0, 0, 0, 0, 1, 0.6 });
trainingInput.Add(inputKeys, new double[] { 255, 255, 255 });
trainingOutput.Add(outputKeys, new double[] { 0, 0, 0, 0, 0, 0, 1 });
trainingInput.Add(inputKeys, new double[] { 0, 0, 0 });
trainingOutput.Add(outputKeys, new double[] { 0, 0, 0, 0, 0, 0, 0 });
trainingInput.Add(inputKeys, new double[] { 128, 128, 128 });
trainingOutput.Add(outputKeys, new double[] { 0, 0, 0, 0, 0, 0, 0.5 });
trainingInput.Add(inputKeys, new double[] { 128, 0, 128 });
trainingOutput.Add(outputKeys, new double[] { 0, 0, 0, 0, 0, 0.5, 0.5 });
var stats = Train(trainingInput, trainingOutput);
var input = new AssociativeArray <double>();
input.Add(inputKeys, new double[] { 240, 2, 20 });
Debug.Log(Run(input).ToString());
}
private void TrainPatterns(InputData input, OutputData output)
{
for (int i = 0; i < input.length; ++i)
{
TrainPattern(input.data[i], output.data[i], true);
}
}
public virtual IContent WritePage(ISource source, IPageData pageData, OutputData outputData)
{
PageMakerUtil.AssertType(source, outputData, SourceOutputType.DataSet);
DataSet ds = outputData.Data.Convert <DataSet>();
var metaTables = GetTableData();
DataSet resultSet = new DataSet(ds.DataSetName)
{
Locale = ds.Locale
};
using (resultSet)
{
foreach (DataTable table in ds.Tables)
{
ITableData tableData;
if (metaTables.TryGetValue(table.TableName, out tableData))
{
resultSet.Tables.Add(CreateResultTable(pageData, ds, table, tableData));
}
else
{
resultSet.Tables.Add(table.Copy());
}
}
ProcessResult(resultSet);
using (XmlReader reader = new XmlDataSetReader(resultSet, true, false))
{
string xml = XmlUtil.GetJson(reader);
return(new SimpleContent(ContentTypeConst.JSON, xml));
}
}
}
public void DelegatesBlocks()
{
var parameters = new Dictionary<string, object>();
parameters["sampleRate"] = new Measurement(1000, "Hz");
var s = new DelegatedStimulus("DelegatedStimulus", "units",
parameters,
(p, b) => new OutputData(Enumerable.Range(0, (int)(b.TotalSeconds * (double)((IMeasurement)p["sampleRate"]).QuantityInBaseUnit))
.Select(i => new Measurement(i, "units")).ToList(),
(IMeasurement)p["sampleRate"],
false),
(p) => Option<TimeSpan>.None());
var block = TimeSpan.FromMilliseconds(100);
IEnumerator<IOutputData> iter = s.DataBlocks(block).GetEnumerator();
int n = 0;
while (iter.MoveNext() && n < 100)
{
var expected =
new OutputData(
Enumerable.Range(0, (int)(block.TotalSeconds * (double)((IMeasurement)parameters["sampleRate"]).QuantityInBaseUnit))
.Select(i => new Measurement(i, "units")).ToList(),
(IMeasurement)parameters["sampleRate"],
false);
Assert.That(iter.Current.Duration, Is.EqualTo(expected.Duration));
Assert.That(iter.Current.Data, Is.EqualTo(expected.Data));
n++;
}
}
/// <summary>
/// 直方图训练方法
/// </summary>
/// <param name="Test">测试集</param>
/// <param name="Train">训练集</param>
/// <param name="levels">分类级别</param>
/// <param name="equation">距离函数指令</param>
/// <returns></returns>
public bool GetHistAnswer(List <string> Test, List <string> Train, int levels, int equation)
{
FreeContainer.FreeTable(BriefAccu);
string[] column = { "实验序号", "总正确率" };
for (int i = 0; i < column.Length; i++)
{
DataColumn dc = new DataColumn(column[i]);
BriefAccu.Columns.Add(dc);
}
for (int i = 0; i < Test.Count && i < Train.Count; i++)
{
List <string> TestSample = new List <string>();
List <string> TrainSample = new List <string>();
GetSamplelist(Test[i], out TestSample); //从测试集文件中取出剖面ID
GetSamplelist(Train[i], out TrainSample); //从训练集文件中取出剖面ID
HistogramMatrix(TestSample, TrainSample, equation); //计算距离矩阵
AnswerAnalysis(Matrix, levels); //计算匹配剖面
AccuracyAnalysis(Profile, i + 1); //计算匹配剖面类型
MixMatrix(Profile); //计算混淆矩阵
MixAccuracy(MMatrix); //计算该次实验的总精确度
OutputData od = new OutputData(); //输出该次实验结果
od.ExportToCsv(Config.MatrixFolder, "实验" + (i + 1).ToString() + "混淆矩阵", MMatrix);
od.ExportToCsv(Config.MatrixFolder, "实验" + (i + 1).ToString() + "匹配结果", AMatrix);
AuxiliaryFunc.percent += 90 / Train.Count;
}
return(true);
}
public OutputData DoAction(IInputData input)
{
if (input.IsPost)
{
try
{
return(DoPost(input));
}
catch (WebPostException ex)
{
return(OutputData.CreateToolkitObject(ex.CreateErrorResult()));
}
}
else
{
ExpandoObject bag = new ExpandoObject();
AddObject(input, bag);
if (UseCallerInfo)
{
input.CallerInfo.AddInfo(bag);
}
return(OutputData.CreateObject(bag));
}
}
/**************************************************************************
* Name: Upload
* Inputs: o - OutputData data structure
* Outputs:
* Purpose: This function sends the data to the PHP file on our server which will write it into a text file. These text files will then be parsed to be put into an excel spreadsheet.
**************************************************************************/
IEnumerator Upload(OutputData o)
{
List <IMultipartFormSection> formData = new List <IMultipartFormSection>();
/*Add form fields. MultipartFormDataSection takes a string field name, and a string or byte array for data*/
formData.Add(new MultipartFormDataSection("trial-number", o.trialNumber.ToString()));
formData.Add(new MultipartFormDataSection("time-stimulus", o.stimStartTime.ToString()));
formData.Add(new MultipartFormDataSection("trial-type", o.stimType.ToString()));
formData.Add(new MultipartFormDataSection("time-response", o.respStartTime.ToString()));
formData.Add(new MultipartFormDataSection("response", o.respAction.name));
formData.Add(new MultipartFormDataSection("control", o.control.displayName));
/*Send form to PHP file*/
UnityWebRequest www = UnityWebRequest.Post(targetURL, formData);
yield return(www.SendWebRequest());
if (www.result != UnityWebRequest.Result.Success)
{
Debug.Log(www.error);
}
else
{
Debug.Log("Form upload complete.");
}
}
public override OutputData DoAction(IInputData input)
{
try
{
DataRow row = Resolver.Query(input.QueryString);
row.BeginEdit();
try
{
row[NickName] = Status;
if (UpdateTrackField)
{
Resolver.UpdateTrackField(UpdateKind.Update, row);
}
}
finally
{
row.EndEdit();
}
Resolver.SetCommands(AdapterCommand.Update);
Resolver.UpdateDatabase();
return(OutputData.CreateToolkitObject(Resolver.CreateKeyData()));
}
catch (WebPostException ex)
{
return(OutputData.CreateToolkitObject(ex.CreateErrorResult()));
}
}
/// <summary>
/// Display interpreted data to Table View
/// </summary>
/// <param name="outputData">Processed data</param>
private void UpdateToTableView(OutputData outputData)
{
if (outputData == null)
{
return;
}
if (OutputDataList == null)
{
OutputDataList = new ObservableCollection <OutputData>();
}
OutputDataList.Add(
new OutputData()
{
PortNumber = outputData.PortNumber,
Timestamp = outputData.Timestamp,
ReceiverName = outputData.ReceiverName,
RawData = outputData.RawData,
Account = outputData.Account,
EventCode = outputData.EventCode,
EventDescription = outputData.EventDescription,
EventQualifier = outputData.EventQualifier,
Partition = outputData.Partition
});
RaisePropertyChanged(() => OutputDataList);
}
public async Task <OutputData> FilterDataByParam(string connectionString, string ProviderName, [FromBody] Param value)
{
OutputData outData = new OutputData();
//var reponse = await exSp.GetFilterDataByParam(connectionString, value);
switch (ProviderName.ToLower())
{
case "sqlserver":
outData = await exSp.GetFilterDataByParam(connectionString, value);
break;
case "postgresql":
outData = await PostgreSQLClass.GetFilterDataByParam(connectionString, value);
break;
//case "mysql":
// reponse = await MySqlClass.GetChartsData(connectionString, value);
//break;
case "oracle":
break;
}
return(outData);
}
public void CombinesParameters()
{
var measurements = new List<IMeasurement> { new Measurement(1, "V") };
var data = new OutputData(measurements, new Measurement(1, "Hz"), false);
var s1 = new RenderedStimulus("stim1", new Dictionary<string, object>()
{
{"key1", "value"},
{"key2", 5}
}, data);
var s2 = new RenderedStimulus("stim2", new Dictionary<string, object>()
{
{"key1", "value"},
{"key2", 2},
{"key3", 0}
}, data);
var combine = new CombinedStimulus("CombinedStimulus", new Dictionary<string, object>(), new List<IStimulus>() {s1, s2}, CombinedStimulus.Add);
var expected = new Dictionary<string, object>();
expected["stim0_stimulusID"] = "stim1";
expected["stim0_key1"] = "value";
expected["stim0_key2"] = 5;
expected["stim1_stimulusID"] = "stim2";
expected["stim1_key1"] = "value";
expected["stim1_key2"] = 2;
expected["stim1_key3"] = 0;
Assert.That(combine.Parameters, Is.EqualTo(expected));
}
public OutputData DoAction(IInputData input)
{
try
{
FileInfo info = input.PostObject.Convert <FileInfo>();
if (string.IsNullOrEmpty(info.FileName))
{
throw new WebPostException(string.Empty,
new FieldErrorInfo("Import", "FileName", "没有文件，请上传Excel文件"));
}
ImportResultData result = new ImportResultData(fMetaData);
ExcelImporter.ExcelImport(Context, info.ServerPath, fMetaData, result);
var errorCollection = fResolver.Import(result.ImportDataSet, input);
result.ImportFieldInfoError(errorCollection);
result.SaveTemp();
return(OutputData.CreateObject(result));
}
catch (WebPostException ex)
{
return(OutputData.CreateToolkitObject(ex.CreateErrorResult()));
}
catch (Exception ex)
{
return(OutputData.CreateToolkitObject(new WebErrorResult(ex.Message)));
}
}
public override OutputData DoAction(IInputData input)
{
if (MainResolver != null)
{
IParamBuilder builder;
if (FilterSql != null)
{
builder = ParamBuilder.CreateSql(Expression.Execute(FilterSql, this));
}
else
{
builder = ParamBuilder.CreateSql("1=1");
}
MainResolver.Select(builder, OrderBy);
MetaDataTableResolver metaResolver = MainResolver as MetaDataTableResolver;
if (metaResolver != null)
{
metaResolver.Decode(input.Style);
}
}
if (UseCallerInfo)
{
input.CallerInfo.AddInfo(DataSet);
}
return(OutputData.Create(DataSet));
}
public OutputData<UserData> Login(UserData user)
{
IUserRepository userRepository = _UserRepository ?? new UserRepository();
Mapper.CreateMap<UserData, User>();
User us = Mapper.Map<UserData, User>(user);
//us.MobileNumber = user.MobileNumber;
//us.Email = user.Email;
//us.Password = user.Password;
OutputData<UserData> ud = new OutputData<UserData>();
if (userRepository.Login(us) != null)
{
ud.Success = 1;
ud.Message = "Login successfully";
ud.Result = null;
return ud;
}
else
{
ud.Success = 0;
ud.Message = "Failed to login";
ud.Result = null;
return ud;
}
}
protected override OutputData DoGet(IInputData input)
{
using (TableResolver resolver = PlugInFactoryManager.CreateInstance <TableResolver>(
ResolverPlugInFactory.REG_NAME, "TaxDocument", this))
{
MetaDataTableResolver metaResolver = resolver as MetaDataTableResolver;
string conditionStr = string.Empty;
if (metaResolver != null)
{
Dictionary <string, string> query = new Dictionary <string, string>
{
{ "Title", input.QueryString["Title"] }
};
IParamBuilder builder = metaResolver.GetQueryCondition(new QueryConditionObject(false, query));
if (builder != null)
{
QueryCondition condition = new QueryCondition(query, builder);
conditionStr = "&Condition=" + HttpUtility.UrlEncode(condition.ToEncodeString());
}
}
string url = WebUtil.ResolveUrl("~/Library/WebListXmlPage.tkx?Source=Cxcs/FaGui");
return(OutputData.Create(url + conditionStr));
}
}
public static async Task PollUserData(Microsoft.AspNetCore.Http.HttpContext e, Oauth.E_RPWS_User user, Entities.WebPebbleProject non_proj)
{
//Write out user settings and projects
OutputData output = new OutputData();
//Get the projects list from this user.
var collect = Program.database.GetCollection <Entities.WebPebbleProject>("projects");
var projects = collect.Find(x => x.authorId == user.uuid).ToArray();
//Convert this to a smaller format.
output.projects = new ProjectsListFormat[projects.Length];
//Convert
for (int i = 0; i < output.projects.Length; i++)
{
ProjectsListFormat f = new ProjectsListFormat();
var proj = projects[i];
f.href = "https://webpebble.get-rpws.com/project/" + proj.projectId + "/manage/";
f.icon = "";
f.id = proj.projectId;
f.name = proj.name;
output.projects[i] = f;
}
//Now, copy settings.
output.settings = new OutputDataSettings
{
theme = user.webpebble_data.theme
};
//Write this
await Program.QuickWriteJsonToDoc(e, output);
}
public override OutputData DoAction(IInputData input)
{
using (WeixinMassResolver massResolver = new WeixinMassResolver(this))
using (TaxDocumentResolver docResolver = new TaxDocumentResolver(this))
{
string docId = input.QueryString["DocId"];
DataRow docRow = docResolver.SelectRowWithKeys(docId);
string massId = docRow["MassId"].ToString();
if (string.IsNullOrEmpty(massId))
{
docResolver.SetCommands(AdapterCommand.Update);
massId = massResolver.NewRow(docId);
docRow.BeginEdit();
docRow["MassId"] = massId;
docRow["MassFlag"] = 0;
docRow.EndEdit();
UpdateUtil.UpdateTableResolvers(null, docResolver, massResolver);
}
string retUrl = input.QueryString["RetUrl"];
if (!string.IsNullOrEmpty(retUrl))
{
retUrl = "&RetUrl=" + HttpUtility.UrlEncode(retUrl);
}
string url = string.Format("~/Library/WebUpdateXmlPage.tkx?Source=CXCS/WeixinMass&MassId={0}{1}", massId, retUrl);
return(OutputData.Create(url));
}
}
protected override OutputData DoGet(IInputData input)
{
Tk5TableResolver getResovler = new Tk5TableResolver(@"Weixin\CorpTagDept.xml", this);
using (getResovler)
{
DataTable table = getResovler.CreateVirtualTable();
IParamBuilder builder = SqlParamBuilder.CreateEqualSql(Context, "CU_USER_ID",
TkDataType.Int, input.QueryString["UserId"]);
string dept = DbUtil.ExecuteScalar(SQL, Context, builder).ToString();
QuoteStringList list = dept.Value <QuoteStringList>();
if (list != null)
{
List <int> deptList = list.ConvertToList <int>();
if (deptList != null)
{
foreach (var item in deptList)
{
DataRow userRow = table.NewRow();
userRow["DeparmentId"] = item;
table.Rows.Add(userRow);
}
getResovler.Decode(input.Style);
}
}
input.CallerInfo.AddInfo(DataSet);
}
return(OutputData.Create(DataSet));
}
public PageDataEventArgs(ISource source, IInputData input, OutputData outputData, object pageData)
{
PageData = pageData;
Source = source;
Input = input;
OutputData = outputData;
}
public EtcsBrakingData()
{
Input = new InputData();
Middle = new MiddleData();
Output = new OutputData();
Params = new ConstantData();
}
public OutputData GetOutputData(string id, int firstPaymentId, DateTime dueDate, InputData inputData)
{
if (inputData == null || inputData.People == null || inputData.People.Count() == 0)
{
return(null);
}
var dateTime = DateTime.Now;
var outputData = new OutputData
{
CstmrCdtTrfInitn = new CstmrCdtTrfInitn
{
GrpHdr = ParseHeader(id, inputData.People),
PaymentInformations = new List <PaymentInformation>()
}
};
foreach (var person in inputData.People.Where(p => p != null))
{
var paymentInformations = outputData.CstmrCdtTrfInitn.PaymentInformations;
ParsePaymentData(firstPaymentId++, paymentInformations, dueDate, person);
}
return(outputData);
}
public override OutputData DoAction(IInputData input)
{
if (input.Style.Style == PageStyle.Insert)
{
if (input.IsPost)
{
try
{
return(Source.Insert(input, input.PostObject));
}
catch (WebPostException ex)
{
return(OutputData.CreateToolkitObject(ex.CreateErrorResult()));
}
}
else
{
EditObjectModel model = new EditObjectModel();
object newObject = Source.CreateNew(input);
ObjectContainer container = new ObjectContainer(newObject);
model.Object = container;
IEnumerable <IFieldInfoEx> fields = GetFields();
container.Decode(fields);
model.FillCodeTable(fields);
input.CallerInfo.AddInfo(model.CallerInfo);
return(OutputData.CreateObject(model));
}
}
else
{
return(ErrorPageStyle(PageStyle.Insert, input));
}
}
private bool TrainingTick(InputData input, OutputData output, AssociativeArray <double> status, DateTime endTime)
{
// Condition d'arrêt
if (status["iterations"] >= iterations || status["error"] <= errorThresh /*|| DateTime.Now >= endTime*/)
{
return(false);
}
++status["iterations"];
// Si on a choisi l'option "log"
if (log && (status["iterations"] % logPeriod == 0))
{
status["error"] = CalculateTrainingError(input, output);
Debug.Log("iterations: " + status["iterations"] + ", training error: " + status["error"]);
}
else
{
if (status["iterations"] % errorCheckInterval == 0)
{
status["error"] = CalculateTrainingError(input, output);
}
else
{
TrainPatterns(input, output);
}
}
return(true);
}
public void Init(IStreamHost host)
{
this.host = host;
this.i1 = host.CreateInputStream<DoubleStream>("Stream In");
this.o1 = host.CreateOutput<double>("Output 1");
}
public OutputData Update(IInputData input, object instance)
{
ServiceAccount account = instance.Convert <ServiceAccount>();
account.Update();
return(OutputData.CreateToolkitObject(KeyData.Empty));
}
OutputData ISmartTranslationStrategy.RetrieveSmartTranslation(InputData inputData)
{
OutputData outputData = new OutputData();
SmartTranslationProvider smartTranslationProvider = new SmartTranslationProvider();
outputData.BasicTranslation = smartTranslationProvider.GetBasicTranslation(inputData);
return(smartTranslationProvider.AddSmartTranslation(outputData.BasicTranslation));
}
public override OutputData DoAction(IInputData input)
{
CodeTable table = PlugInFactoryManager.CreateInstance <CodeTable>(
CodeTablePlugInFactory.REG_NAME, RegName);
table.Fill(DataSet, Context);
return(OutputData.Create(DataSet));
}
public DependencyResource(string urn)
: base(type: "", name: "", args: ResourceArgs.Empty, dependency: true)
{
var resources = ImmutableHashSet.Create <Resource>(this);
var data = OutputData.Create(resources, urn, isKnown: true, isSecret: false);
this.Urn = new Output <string>(Task.FromResult(data));
}
private void button3_Click(object sender, EventArgs e)
{
AuxiliaryFunc.percent = 0;
string[] SheetName = { "基础信息", "混淆矩阵", "剖面匹配结果" };
Thread newthread = new Thread(new ThreadStart(RunTask)); newthread.Start();
OutputData.ExportExcel("波形相似度匹配", Parameter.BriefInformation("波形相似度匹配"), MatchDis.HMatrix, MatchDis.HProfile, SheetName);
}
public void OutputPipelineContinuity(
[Values(1000, 5000, 10000, 15000, 20000)] double sampleRate,
[Values(0.1, 0.5, 1, 5)] double blockDurationSeconds
)
{
const double epochDuration = 2; //seconds
var srate = new Measurement((decimal) sampleRate, "Hz");
var daq = new TestDAQController();
var outStream = new DAQOutputStream("OUT")
{
SampleRate = srate,
MeasurementConversionTarget = "V"
};
var inStream = new DAQInputStream("IN")
{
SampleRate = srate,
MeasurementConversionTarget = "V"
};
var controller = new Controller() { Clock = daq, DAQController = daq };
var dev = new UnitConvertingExternalDevice("dev", "co", controller, new Measurement(0, "V"))
{
Clock = daq,
MeasurementConversionTarget = "V",
OutputSampleRate = srate,
InputSampleRate = srate
};
dev.BindStream(outStream).BindStream(inStream);
// Setup Epoch
var e = new Epoch("OutputPipelineContinuity");
var nSamples = (int)TimeSpan.FromSeconds(epochDuration).Samples(srate);
IList<IMeasurement> stimData = (IList<IMeasurement>) Enumerable.Range(0, nSamples)
.Select(i => new Measurement((decimal) (8 * Math.Sin(((double)i) / (nSamples / 10.0))), "V") as IMeasurement)
.ToList();
IOutputData stimOutputData = new OutputData(stimData, srate);
var stim = new RenderedStimulus((string) "RenderedStimulus", (IDictionary<string, object>) new Dictionary<string, object>(),
stimOutputData);
e.Stimuli[dev] = stim;
e.Responses[dev] = new Response();
e.Backgrounds[dev] = new Background(new Measurement(0, "V"), srate);
controller.EnqueueEpoch(e);
var blockSpan = TimeSpan.FromSeconds(blockDurationSeconds);
foreach (var stimBlock in stim.DataBlocks(blockSpan))
{
var cons = stimOutputData.SplitData(blockSpan);
var expected = cons.Head.Data;
stimOutputData = cons.Rest;
Assert.That(stimBlock.Data, Is.EqualTo(expected));
}
}
public IContent WritePage(ISource source, IPageData pageData, OutputData outputData)
{
//DataSet ds = outputData.Data as DataSet;
//TkDebug.AssertArgumentNull(ds, "ds", null);
//DataTable table = ds.Tables[fMetaData.Table.TableName];
byte[] midArray = NPOIWrite.ExportExcel(outputData, this);
string fileName = fMetaData.Table.TableDesc + ".xls";
FileContent file = new FileContent(NetUtil.GetContentType(fileName), fileName, midArray);
return new WebFileContent(file);
}
public OutputData GetOutputData(InputData inputData)
{
var result = new OutputData
{
Servers = inputData.Servers
};
// TODO: add some logic here
return result;
}
public void Init(IStreamHost host)
{
this.host = host;
this.testinputstream = host.CreateInputStream<IBaseStream>("Stream In");
this.testoutputstream = host.CreateOutputStream<IBaseStream>("Stream Out");
this.p1 = host.CreateParameter<double>("Param 1");
this.p2 = host.CreateParameter<double>("Param 2");
this.testoutdata = host.CreateOutput<double>("Out 1");
}
public void FiresStimulusOutputEvents()
{
var c = new TestDAQController();
var srate = new Measurement(10, "Hz");
var outStream = new DAQOutputStream("out")
{
MeasurementConversionTarget = "V",
SampleRate = srate
};
var inStream = new DAQInputStream("in")
{
MeasurementConversionTarget = "V",
SampleRate = srate
};
var outputData = new Dictionary<IDAQOutputStream, Queue<IOutputData>>();
var dataQueue = new Queue<IOutputData>();
var outputIOData = new OutputData(
Enumerable.Range(0, 100).Select(i => new Measurement(i, "V")),
new Measurement(10, "Hz")
);
dataQueue.Enqueue(outputIOData);
outputData[outStream] = dataQueue;
var dev = new TestDevice("test", outputData) { MeasurementConversionTarget = "V" };
dev.BindStream(outStream);
bool fired = false;
c.StimulusOutput += (daq, args) =>
{
Assert.That(args.Stream == outStream);
Assert.That(args.Data != null);
Assert.That(args.Data.Configuration.Count() > 0);
fired = true;
((IDAQController) daq).RequestStop();
};
c.AddStreamMapping(outStream, inStream);
c.Start(false);
while (c.IsRunning)
{
Thread.Sleep(1);
}
Assert.That(fired, Is.True);
}
public void ConcatThrowsForSampleRateMismatch()
{
var srate1 = new Measurement(1000, "Hz");
var srate2 = new Measurement(100, "Hz");
IOutputData outData1 = new OutputData(this.Data,
srate1, false);
IOutputData outData2 = new OutputData(this.Data,
srate2, false);
Assert.Throws<ArgumentException>(() => outData1.Concat(outData2));
Assert.Throws<ArgumentException>(() => outData2.Concat(outData1));
}
public OutputData<UserData> Login(UserData user)
{
if (user != null)
{
IUserController userController = _UserController ?? new UserController();
return userController.Login(user);
}
else
{
OutputData<UserData> userData = new OutputData<UserData>();
userData.Success = 1;
userData.Message = "User information is null";
userData.Result = null;
return userData;
}
}
public void ConcatenatesOutputData()
{
IMeasurement srate = new Measurement(1000, "Hz");
IOutputData outData1 = new OutputData(this.Data,
srate, false);
IOutputData outData2 = new OutputData(this.Data.Concat(this.Data).ToList(),
srate, true);
var actual = outData1.Concat(outData2);
var expectedData = this.Data.Concat(this.Data).Concat(this.Data).ToList();
Assert.That(actual.Data, Is.EqualTo(expectedData));
Assert.That(actual.SampleRate, Is.EqualTo(srate));
}
public void ConcatSetsIsLast()
{
IMeasurement srate = new Measurement(1000, "Hz");
IOutputData outData1 = new OutputData(this.Data,
srate, false);
IOutputData outData2 = new OutputData(this.Data,
srate, true);
Assert.That(outData1.IsLast, Is.Not.EqualTo(outData2.IsLast));
Assert.That(outData1.Concat(outData1).IsLast, Is.EqualTo(outData1.IsLast));
Assert.That(outData2.Concat(outData2).IsLast, Is.EqualTo(outData2.IsLast));
Assert.That(outData1.Concat(outData2).IsLast, Is.True);
Assert.That(outData2.Concat(outData1).IsLast, Is.True);
}
protected sealed override byte[] CreateExcelData(ExcelExporter exporter, OutputData outputData)
{
byte[] data = null;
switch (outputData.OutputType)
{
case SourceOutputType.ToolkitObject:
case SourceOutputType.Object:
ObjectListModel model = outputData.Data as ObjectListModel;
if (model != null)
data = exporter.Export(model);
break;
case SourceOutputType.DataSet:
data = exporter.Export(outputData.Data.Convert<DataSet>());
break;
}
return data;
}
public void CombinesDataBlocks(
[Values(100, 500, 1000, 5000)] double blockMilliseconds,
[Values(5000, 10000)] double sampleRateHz,
[Values(1, 4)] int numStim
)
{
var parameters = new Dictionary<string, object>();
var sampleRate = new Measurement((decimal)sampleRateHz, "Hz");
var data = new List<IOutputData>();
var stimuli = new List<IStimulus>();
for (int i = 0; i < numStim; i++)
{
IOutputData d = new OutputData(Enumerable.Range(0, (int)TimeSpan.FromSeconds(3).Samples(new Measurement((decimal)sampleRateHz, "Hz")))
.Select(j => new Measurement(j, "units")).ToList(),
sampleRate,
false);
data.Add(d);
stimuli.Add(new RenderedStimulus((string)"RenderedStimulus" + i, (IDictionary<string, object>)parameters, d));
}
var combined = new CombinedStimulus("CombinedStimulus", new Dictionary<string, object>(), stimuli, CombinedStimulus.Add);
var blockSpan = TimeSpan.FromMilliseconds(blockMilliseconds);
IEnumerator<IOutputData> iter = combined.DataBlocks(blockSpan).GetEnumerator();
while (iter.MoveNext())
{
IOutputData expectedData = null;
foreach (var d in data.ToList())
{
var cons = d.SplitData(blockSpan);
data[data.IndexOf(d)] = cons.Rest;
expectedData = expectedData == null
? cons.Head
: expectedData.Zip(cons.Head, (m1, m2) => new Measurement(m1.QuantityInBaseUnits + m2.QuantityInBaseUnits, 0, m1.BaseUnits));
}
Assert.That(iter.Current.Duration, Is.EqualTo(expectedData.Duration));
Assert.That(iter.Current.Data, Is.EqualTo(expectedData.Data));
}
}
private void button3_Click(object sender, EventArgs e)
{
OutputData output = new OutputData("Test Test case name", "221");
Round r1 = new Round("R1", "test des for 1");
CheckPoint cp = new CheckPoint("cp1", "des for cp1");
cp.Inputs.AddParameter("input para1", "v1");
cp.Inputs.AddParameter("input para2", "v2");
cp.Inputs.AddParameter("input para3", "v3");
cp.Inputs.AddParameter("input para4", "v4");
cp.Outpus.AddParameter("output1", "v5");
cp.Outpus.AddParameter("output2", "v6");
cp.Outpus.AddParameter("output3", "v7");
cp.ExpectedValues.AddParameter("E1", "v8");
cp.ExpectedValues.AddParameter("E2", "v9");
cp.ExpectedValues.AddParameter("E3", "v10");
cp.Result = TestResult.Pass;
r1.CheckPoints.Add(cp);
CheckPoint cp2 = new CheckPoint("cp1", "des for cp1");
cp2.Inputs.AddParameter("input para1", "v1");
cp2.Inputs.AddParameter("input para2", "v2");
cp2.Inputs.AddParameter("input para3", "v3");
cp2.Inputs.AddParameter("input para4", "v4");
cp2.Outpus.AddParameter("output1", "v5");
cp2.Outpus.AddParameter("output2", "v6");
cp2.Outpus.AddParameter("output3", "v7");
cp2.ExpectedValues.AddParameter("E1", "v8");
cp2.ExpectedValues.AddParameter("E2", "v9");
cp2.ExpectedValues.AddParameter("E3", "v10");
cp2.Result = TestResult.Fail;
r1.CheckPoints.Add(cp);
output.Rounds.Add(r1);
output.ConvertToXml("C:/tss.xml");
}
public OutputData<UserData> SignUp(UserData user)
{
try
{
if (user != null)
{
IUserController userController = _UserController ?? new UserController();
return userController.SingUpUser(user);
}
}
catch (Exception ex)
{
LoggingFactory.InitializeLogFactory(new Log4NetAdapter());
ILogger log = LoggingFactory.GetLogger();
log.Log(ex.Message);
OutputData<UserData> userData = new OutputData<UserData>();
userData.Success = 0;
userData.Message = ex.Message;
userData.Result = null;
return userData;
}
return null;
}
public static byte[] ExportExcel(OutputData dataSource, ExportExcelPageMaker configData)
{
MemoryStream ms = new MemoryStream();
using (ms)
{
IWorkbook workbook = new HSSFWorkbook();
ISheet sheet = workbook.CreateSheet(configData.fMetaData.Table.TableDesc);
HeaderSetting(configData, workbook, sheet);
Dictionary<string, ICellStyle> ContentStyles = GetContentStyles(workbook, configData);
if (dataSource.Data is DataSet)
{
DataSet ds = (DataSet)dataSource.Data;
TkDebug.AssertArgumentNull(ds, "ds", null);
DataTable dt = ds.Tables[configData.fMetaData.Table.TableName];
if (dt != null)
{
DataTableExport(configData, ContentStyles, sheet, dt);
}
}
if (dataSource.Data is ObjectListModel)
{
ObjectListModel objectLM = (ObjectListModel)dataSource.Data;
if (objectLM.List != null)
{
ObjectExport(configData, ContentStyles, sheet, objectLM);
}
}
workbook.Write(ms);
ms.Flush();
return ms.ToArray();
}
}
protected sealed override byte[] CreateExcelData(ExcelExporter exporter, OutputData outputData)
{
byte[] data = exporter.CreateExcelTemplate();
return data;
}
public EraIndex(string csvpath, OutputData outdata, MainForm mf)
: base(outdata, mf)
{
filepath = csvpath + "EraIndex.html";
}
public void ShouldAllowLongStringEpochParameters()
{
if (File.Exists("..\\..\\..\\ShouldAllowLongStringEpochParameters.h5"))
File.Delete("..\\..\\..\\ShouldAllowLongStringEpochParameters.h5");
var gID = new Guid("{2F2719F7-4A8C-4C22-9698-BE999DBC5385}");
using (
var exp = new EpochHDF5Persistor("..\\..\\..\\ShouldAllowLongStringEpochParameters.h5", null, () => gID)
)
{
var time = new DateTimeOffset(1000, TimeSpan.Zero);
var guid = new Guid("053C64D4-ED7A-4128-AA43-ED115716A97D");
var props = new Dictionary<string, object>();
props["key1"] =
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";
//100 elements
props["key2"] = 2;
const string protocolID = "Epoch.Fixture";
Dictionary<string, object> parameters = props;
dev1 = new UnitConvertingExternalDevice(dev1Name, "DEVICECO", new Measurement(0, "V"));
dev2 = new UnitConvertingExternalDevice(dev2Name, "DEVICECO", new Measurement(0, "V"));
var stream1 = new DAQInputStream("Stream1");
var stream2 = new DAQInputStream("Stream2");
var stimParameters = new Dictionary<string, object>();
stimParameters[param1] = value1;
stimParameters[param2] = value2;
var srate = new Measurement(1000, "Hz");
List<Measurement> samples =
Enumerable.Range(0, 10000).Select(i => new Measurement((decimal) Math.Sin((double) i/100), "mV")).
ToList();
var stimData = new OutputData(samples, srate, false);
var stim1 = new RenderedStimulus("RenderedStimulus", stimParameters, stimData);
//.Data does not need to be persisted
var stim2 = new RenderedStimulus("RenderedStimulus", stimParameters, stimData);
//.Data does not need to be persisted
var e = new Epoch(protocolID, parameters);
e.Stimuli[dev1] = stim1;
e.Stimuli[dev2] = stim2;
DateTimeOffset start = DateTimeOffset.Parse("1/11/2011 6:03:29 PM -08:00");
// Do this to match the XML stored in the EpochXML.txt resource
e.StartTime = Maybe<DateTimeOffset>.Yes(start);
e.Background[dev1] = new Epoch.EpochBackground(new Measurement(0, "V"), new Measurement(1000, "Hz"));
e.Background[dev2] = new Epoch.EpochBackground(new Measurement(1, "V"), new Measurement(1000, "Hz"));
e.Responses[dev1] = new Response();
e.Responses[dev2] = new Response();
var streamConfig = new Dictionary<string, object>();
streamConfig[param1] = value1;
var devConfig = new Dictionary<string, object>();
devConfig[param2] = value2;
IInputData responseData1 = new InputData(samples, srate, start)
.DataWithStreamConfiguration(stream1, streamConfig)
.DataWithExternalDeviceConfiguration(dev1, devConfig);
IInputData responseData2 = new InputData(samples, srate, start)
.DataWithStreamConfiguration(stream2, streamConfig)
.DataWithExternalDeviceConfiguration(dev2, devConfig);
e.Responses[dev1].AppendData(responseData1);
e.Responses[dev2].AppendData(responseData2);
e.Keywords.Add(kw1);
e.Keywords.Add(kw2);
exp.BeginEpochGroup("label", "source identifier", new[] {"keyword1", "keyword2"}, props, guid,
time);
exp.Serialize(e);
exp.EndEpochGroup(time.AddMilliseconds(100));
exp.Close();
}
H5.Close();
var startInfo = new ProcessStartInfo(@"..\..\..\..\..\..\externals\HDF5\bin\h5dump",
@" --xml ..\..\..\ShouldAllowLongStringEpochParameters.h5");
startInfo.RedirectStandardOutput = true;
startInfo.UseShellExecute = false;
Process proc = Process.Start(startInfo);
Approvals.VerifyXml(proc.StandardOutput.ReadToEnd());
}
public void ShouldAllowNumericEpochParameters()
{
if (File.Exists("..\\..\\..\\ShouldAllowNumericEpochParameters.h5"))
File.Delete("..\\..\\..\\ShouldAllowNumericEpochParameters.h5");
var gID = new Guid("{2F2719F7-4A8C-4C22-9698-BE999DBC5385}");
using (var exp = new EpochHDF5Persistor("..\\..\\..\\ShouldAllowNumericEpochParameters.h5", null, () => gID)
)
{
var time = new DateTimeOffset(1000, TimeSpan.Zero);
var guid = new Guid("053C64D4-ED7A-4128-AA43-ED115716A97D");
var props = new Dictionary<string, object>();
props["int"] = 2;
props["float"] = 2.0f;
props["double"] = 2.0d;
props["decimal"] = 2.0m;
props["array"] = new[] {1.0, 2.0, 3.0};
props["short"] = (short) 2;
props["unit16"] = (UInt16) 1;
props["uint32"] = (UInt32) 2;
props["byte"] = (byte) 1;
props["bool"] = true;
const string protocolID = "Epoch.Fixture";
Dictionary<string, object> parameters = props;
dev1 = new UnitConvertingExternalDevice(dev1Name, "DEVICECO", new Measurement(0, "V"));
dev2 = new UnitConvertingExternalDevice(dev2Name, "DEVICECO", new Measurement(0, "V"));
var stream1 = new DAQInputStream("Stream1");
var stream2 = new DAQInputStream("Stream2");
var stimParameters = new Dictionary<string, object>();
stimParameters[param1] = value1;
stimParameters[param2] = value2;
var srate = new Measurement(1000, "Hz");
List<Measurement> samples =
Enumerable.Range(0, 10000).Select(i => new Measurement((decimal) Math.Sin((double) i/100), "V")).
ToList();
var stimData = new OutputData(samples, srate, false);
var stim1 = new RenderedStimulus("RenderedStimulus", stimParameters, stimData);
//.Data does not need to be persisted
var stim2 = new RenderedStimulus("RenderedStimulus", stimParameters, stimData);
//.Data does not need to be persisted
var e = new Epoch(protocolID, parameters);
e.Stimuli[dev1] = stim1;
e.Stimuli[dev2] = stim2;
DateTimeOffset start = DateTimeOffset.Parse("1/11/2011 6:03:29 PM -08:00");
// Do this to match the XML stored in the EpochXML.txt resource
e.StartTime = Maybe<DateTimeOffset>.Yes(start);
e.Background[dev1] = new Epoch.EpochBackground(new Measurement(0, "V"), new Measurement(1000, "Hz"));
e.Background[dev2] = new Epoch.EpochBackground(new Measurement(1, "V"), new Measurement(1000, "Hz"));
e.Responses[dev1] = new Response();
e.Responses[dev2] = new Response();
var streamConfig = new Dictionary<string, object>();
streamConfig[param1] = value1;
var devConfig = new Dictionary<string, object>();
devConfig[param2] = value2;
IInputData responseData1 = new InputData(samples, srate, start)
.DataWithStreamConfiguration(stream1, streamConfig)
.DataWithExternalDeviceConfiguration(dev1, devConfig);
IInputData responseData2 = new InputData(samples, srate, start)
.DataWithStreamConfiguration(stream2, streamConfig)
.DataWithExternalDeviceConfiguration(dev2, devConfig);
e.Responses[dev1].AppendData(responseData1);
e.Responses[dev2].AppendData(responseData2);
e.Keywords.Add(kw1);
e.Keywords.Add(kw2);
exp.BeginEpochGroup("label", "source identifier", new[] {"keyword1", "keyword2"}, props, guid,
time);
exp.Serialize(e);
exp.EndEpochGroup();
exp.Close();
}
H5.Close();
Approvals.VerifyFile("..\\..\\..\\ShouldAllowNumericEpochParameters.h5");
}
public void ShouldBitShiftAndMergePulledOutputData()
{
var controller = new NIDAQController();
var s = new NIDigitalDAQOutputStream("OUT", controller);
controller.SampleRate = new Measurement(10000, 1, "Hz");
TimeSpan duration = TimeSpan.FromSeconds(0.5);
for (ushort bitPosition = 1; bitPosition < 32; bitPosition += 2)
{
var dataQueue = new Dictionary<IDAQOutputStream, Queue<IOutputData>>();
dataQueue[s] = new Queue<IOutputData>();
var data = new OutputData(Enumerable.Range(0, 10000).Select(i => new Measurement(i % 2, Measurement.UNITLESS)).ToList(),
s.SampleRate, false);
dataQueue[s].Enqueue(data.SplitData(duration).Head);
dataQueue[s].Enqueue(data.SplitData(duration).Head);
TestDevice dev = new TestDevice("OUT-DEVICE" + bitPosition, dataQueue);
dev.BindStream(s);
s.BitPositions[dev] = bitPosition;
}
var expected = Enumerable.Range(0, 10000).Select(i => new Measurement((long)(i % 2 * 0xaaaaaaaa), Measurement.UNITLESS)).ToList();
var pull1 = s.PullOutputData(duration);
Assert.AreEqual(expected, pull1.Data);
var pull2 = s.PullOutputData(duration);
Assert.AreEqual(expected, pull2.Data);
}
private static Epoch CreateTestEpoch(out ExternalDeviceBase dev1, out ExternalDeviceBase dev2)
{
dev1 = new UnitConvertingExternalDevice("dev1", "man1", new Measurement(0, "V"));
dev2 = new UnitConvertingExternalDevice("dev2", "man2", new Measurement(0, "V"));
var stream1 = new DAQInputStream("Stream1");
var stream2 = new DAQInputStream("Stream2");
var stimParameters = new Dictionary<string, object>();
stimParameters["param1"] = 1;
stimParameters["param2"] = 2;
var srate = new Measurement(1000, "Hz");
List<Measurement> samples =
Enumerable.Range(0, 10000).Select(i => new Measurement((decimal)Math.Sin((double)i / 100), "V")).ToList();
var stimData = new OutputData(samples, srate, false);
var stim1 = new RenderedStimulus("RenderedStimulus", stimParameters, stimData);
var stim2 = new RenderedStimulus("RenderedStimulus", stimParameters, stimData)
{
ShouldDataBePersisted = true
};
var protocolParameters = new Dictionary<string, object>
{
{"one", 1},
{"two", "second"},
{"three", 5.55}
};
var epoch = new TestEpoch("protocol.banana", protocolParameters);
epoch.Stimuli[dev1] = stim1;
epoch.Stimuli[dev2] = stim2;
DateTimeOffset start = DateTimeOffset.Now;
epoch.SetStartTime(Maybe<DateTimeOffset>.Yes(start));
epoch.Backgrounds[dev1] = new Background(new Measurement(0, "V"), new Measurement(1000, "Hz"));
epoch.Backgrounds[dev2] = new Background(new Measurement(1, "V"), new Measurement(1000, "Hz"));
epoch.Responses[dev1] = new Response();
epoch.Responses[dev2] = new Response();
var streamConfig = new Dictionary<string, object>();
streamConfig["configParam1"] = 1;
var devConfig = new Dictionary<string, object>();
devConfig["configParam2"] = 2;
IInputData responseData1 = new InputData(samples, srate, start)
.DataWithStreamConfiguration(stream1, streamConfig)
.DataWithExternalDeviceConfiguration(dev1, devConfig);
IInputData responseData2 = new InputData(samples, srate, start + TimeSpanExtensions.FromSamples((uint) samples.Count, srate))
.DataWithStreamConfiguration(stream1, streamConfig)
.DataWithExternalDeviceConfiguration(dev1, devConfig);
IInputData responseData3 = new InputData(samples, srate, start)
.DataWithStreamConfiguration(stream2, streamConfig)
.DataWithExternalDeviceConfiguration(dev2, devConfig);
IInputData responseData4 = new InputData(samples, srate, start + TimeSpanExtensions.FromSamples((uint)samples.Count, srate))
.DataWithStreamConfiguration(stream2, streamConfig)
.DataWithExternalDeviceConfiguration(dev2, devConfig);
epoch.Responses[dev1].AppendData(responseData1);
epoch.Responses[dev1].AppendData(responseData2);
epoch.Responses[dev2].AppendData(responseData3);
epoch.Responses[dev2].AppendData(responseData4);
epoch.Properties.Add("prop1", 5);
epoch.Properties.Add("prop2", "banana");
epoch.Keywords.Add("word1");
epoch.Keywords.Add("word2");
return epoch;
}
public void Setup()
{
const string protocolID = "Epoch.Fixture";
var parameters = new Dictionary<string, object>();
parameters[param1] = value1;
parameters[param2] = value2;
dev1 = new UnitConvertingExternalDevice(dev1Name, "DEVICECO", new Measurement(0, "V"));
dev2 = new UnitConvertingExternalDevice(dev2Name, "DEVICECO", new Measurement(0, "V"));
var stream1 = new DAQInputStream("Stream1");
var stream2 = new DAQInputStream("Stream2");
var stimParameters = new Dictionary<string, object>();
stimParameters[param1] = value1;
stimParameters[param2] = value2;
var srate = new Measurement(1000, "Hz");
var samples = Enumerable.Range(0, 1000).Select(i => new Measurement((decimal)Math.Sin((double)i / 100), "V")).ToList();
var stimData = new OutputData(samples, srate, false);
RenderedStimulus stim1 = new RenderedStimulus((string) "RenderedStimulus", (IDictionary<string, object>) stimParameters, (IOutputData) stimData); //.Data does not need to be persisted
RenderedStimulus stim2 = new RenderedStimulus((string) "RenderedStimulus", (IDictionary<string, object>) stimParameters, (IOutputData) stimData); //.Data does not need to be persisted
Epoch e = new Epoch(protocolID, parameters);
e.Stimuli[dev1] = stim1;
e.Stimuli[dev2] = stim2;
var start = DateTimeOffset.Parse("1/11/2011 6:03:29 PM -08:00");
// Do this to match the XML stored in the EpochXML.txt resource
e.StartTime = Maybe<DateTimeOffset>.Yes(start);
e.Background[dev1] = new Epoch.EpochBackground(new Measurement(0, "V"), new Measurement(1000, "Hz"));
e.Background[dev2] = new Epoch.EpochBackground(new Measurement(1, "V"), new Measurement(1000, "Hz"));
e.Responses[dev1] = new Response();
e.Responses[dev2] = new Response();
var streamConfig = new Dictionary<string, object>();
streamConfig[param1] = value1;
var devConfig = new Dictionary<string, object>();
devConfig[param2] = value2;
var responseData1 = new InputData(samples, srate, start)
.DataWithStreamConfiguration(stream1, streamConfig)
.DataWithExternalDeviceConfiguration(dev1, devConfig);
var responseData2 = new InputData(samples, srate, start)
.DataWithStreamConfiguration(stream2, streamConfig)
.DataWithExternalDeviceConfiguration(dev2, devConfig);
e.Responses[dev1].AppendData(responseData1);
e.Responses[dev2].AppendData(responseData2);
e.Keywords.Add(kw1);
e.Keywords.Add(kw2);
testEpoch = e;
}
public OutputData<UserData> VerifyUser(UserData user)
{
if (user != null)
{
IUserController userController = _UserController ?? new UserController();
return userController.VerifyUser(user);
}
else
{
OutputData<UserData> userData = new OutputData<UserData>();
userData.Success = 0;
userData.Message = "Verify Code or UserIdentity is Empty or null";
userData.Result = null;
return userData;
}
}
public override IOutputData PullOutputData(TimeSpan duration)
{
if (!Devices.Any())
throw new DAQException("No bound external devices (check configuration)");
IOutputData outData = null;
foreach (var ed in Devices)
{
var pulled = ed.PullOutputData(this, duration).DataWithUnits(MeasurementConversionTarget);
ushort bitPosition = BitPositions[ed];
pulled = new OutputData(pulled, pulled.Data.Select(m =>
{
if (m.QuantityInBaseUnits != 0 && m.QuantityInBaseUnits != 1)
throw new DAQException(ed.Name + " output data must contain only values of 0 and 1");
return MeasurementPool.GetMeasurement((long)((long)m.QuantityInBaseUnits << bitPosition), 0, m.BaseUnits);
}));
outData = outData == null
? pulled
: outData.Zip(pulled,
(m1, m2) =>
MeasurementPool.GetMeasurement((long)m1.QuantityInBaseUnits | (long)m2.QuantityInBaseUnits, 0, m1.BaseUnits));
}
if (!outData.SampleRate.Equals(this.SampleRate))
throw new DAQException("Sample rate mismatch.");
if (outData.IsLast)
LastDataPulled = true;
return outData.DataWithStreamConfiguration(this, this.Configuration);
}
/// <summary>
/// Converts the collected BattleReports into the data format specified by Alex.
/// </summary>
private void WriteData()
{
//Create new output object.
OutputData data = new OutputData();
//Iterate over all battle reports, creating several variables vis post-processing.
int turn = 0;
for (int b = 0; b < this.battleReports.Count; b++) {
List<DamageReport> damageReports = this.battleReports[b].DamageReports;
//Iterate over all damage reports.
for (int d = 0; d < damageReports.Count; d++) {
DamageReport dr = damageReports[d];
//Only output player actions.
if (dr.Attacker.AIControlled) continue;
OutputAction action = new OutputAction(this.pID, turn, b, dr.Power.Name, dr.Power.Element.ToString(),
dr.Multiplier, dr.Defender.Name, dr.Defender.Prototype.Element.ToString(), -1);
data.actions.Add(action);
//Increment counters.
turn++;
}
//Output survey responses.
OutputSurvey survey = new OutputSurvey(this.pID, b, this.surveyReports[b].Q1, this.surveyReports[b].Q2);
data.responses.Add(survey);
}
data.myToCSV("ActionData", "SurveyData");
}
