private TextController textController; //テキストコントローラー
//=================================================================
//コンポーネント参照用
private void ComponentRef()
{
neuralNetworkManager = GameObject.Find("NeuralNetworkManager").GetComponent <NeuralNetworkManager>();
parameterManager = GameObject.Find("ParameterManager").GetComponent <ParameterManager>();
manager = GameObject.Find("Manager").GetComponent <Manager>();
textController = transform.Find("TextController").GetComponent <TextController>();
}
public void FindOverridenParameters_TwoTest()
{
var myParameter1 = new ConstantParameter("DECLARE @fish as int", "1", "fishes be here", new MicrosoftQuerySyntaxHelper());
var myParameter2 = new ConstantParameter("DECLARE @fish as int", "2", "fishes be here", new MicrosoftQuerySyntaxHelper());
var overridingParameter = new ConstantParameter("DECLARE @fish as int", "3", "overriding value", new MicrosoftQuerySyntaxHelper());
var pm = new ParameterManager();
pm.ParametersFoundSoFarInQueryGeneration[ParameterLevel.TableInfo].Add(myParameter1);
pm.ParametersFoundSoFarInQueryGeneration[ParameterLevel.CompositeQueryLevel].Add(myParameter2);
pm.ParametersFoundSoFarInQueryGeneration[ParameterLevel.Global].Add(overridingParameter);
var overrides = pm.GetOverridenParameters().ToArray();
Assert.IsNull(pm.GetOverrideIfAnyFor(overridingParameter));
Assert.AreEqual(pm.GetOverrideIfAnyFor(myParameter1), overridingParameter);
Assert.AreEqual(pm.GetOverrideIfAnyFor(myParameter2), overridingParameter);
Assert.AreEqual(2, overrides.Length);
Assert.AreEqual(myParameter1, overrides[0]);
Assert.AreEqual(myParameter2, overrides[1]);
var final = pm.GetFinalResolvedParametersList().ToArray();
Assert.AreEqual(1, final.Length);
Assert.AreEqual(overridingParameter, final[0]);
}
private double[][] mBufferWeights = null; // matrix with the buffer weights for each channel (1st dimention are the channels; 2nd dimension are the sample weights per channel)
public TimeSmoothingFilter(string filterName)
{
// set class version
base.CLASS_VERSION = CLASS_VERSION;
// store the filter name
this.filterName = filterName;
// initialize the logger and parameters with the filter name
logger = LogManager.GetLogger(filterName);
parameters = ParameterManager.GetParameters(filterName, Parameters.ParamSetTypes.Filter);
// define the parameters
parameters.addParameter <bool> (
"EnableFilter",
"Enable TimeSmoothing Filter",
"1");
parameters.addParameter <bool>(
"LogDataStreams",
"Log the filter's intermediate and output data streams. See 'Data' tab for more settings on sample stream logging.",
"0");
parameters.addParameter <double[][]> (
"BufferWeights",
"Weights corresponding to data buffers (columns correspond to output channels, multiple rows correspond to samples)",
"", "", "0.7,0.5,0.2,0;0.7,0.5,0.2,0");
// message
logger.Info("Filter created (version " + CLASS_VERSION + ")");
}
private void FillParameterList()
{
List <AgingParameter> paraList = ParameterManager.Instance().ParaList;
for (int iLoop = 0; iLoop < paraList.Count; iLoop++)
{
Parameter para = new Parameter();
para.Name = paraList[iLoop].PumpType;
para.SetParameter((iLoop + 1).ToString(),
paraList[iLoop].PumpType,
paraList[iLoop].Rate.ToString(),
paraList[iLoop].Volume.ToString(),
paraList[iLoop].ChargeTime.ToString(),
paraList[iLoop].OclusionLevel.ToString(),
paraList[iLoop].RechargeTime.ToString(),
paraList[iLoop].C9OclusionLevel.ToString());
para.Margin = new Thickness(1);
para.Cursor = Cursors.Hand;
para.OnSelected += OnSelected;
if (iLoop % 2 == 0)
{
para.Background = new SolidColorBrush(Color.FromArgb(0xFF, 0x00, 0xA2, 0xE8));
}
parameterListGrid.Children.Add(para);
Grid.SetRow(para, iLoop + 1);
Grid.SetColumn(para, 0);
}
}
public StepAction Create(ParameterManager processParameterManager)
{
try
{
var stepAction = new StepAction
{
_actionName = _actionName, _bindKey = _bindKey, _bindingDictionaryName = _bindingDictionaryName
};
if (_bindToResourceTemplate)
{
stepAction.AssignAction(processParameterManager);
}
else
{
stepAction.Action = Action.Clone();
stepAction.Action.ActionContainer = Action.ActionContainer;
}
return(stepAction);
}
catch (Exception e)
{
Log.Error($"创建StepAction实例失败，Step名称为：【{_actionName}】,异常为{e.Message}");
return(null);
}
}
/// <summary>
/// 初始化一个<see cref="WhereClauseTest"/>类型的实例
/// </summary>
public WhereClauseTest(ITestOutputHelper output) : base(output)
{
_parameterManager = new ParameterManager(new OracleDialect());
_database = new TestTableDatabase();
_builder = new OracleBuilder(new TestEntityMatedata(), _database, _parameterManager);
_clause = new WhereClause(_builder, new OracleDialect(), new EntityResolver(), new EntityAliasRegister(), _parameterManager);
}
public void FillDestDoente()
{
List <Produtos> list_destTmp = new List <Produtos>();
list_destTmp = ParameterManager.GetParametersFrom <Produtos>("name=" + (string)HttpContext.Current.Session[Constants.SS_LOCAL_CONN], schema, tabela, "VALOR", "CODIGO='DEST_DOENTE'", condition);
list_destDoentes = list_destTmp.Select(s => s.VALOR).ToList();
}
void Awake()
{
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
if (ParameterManager.HasInstance())
{
backgroundScript.SetRotation(ParameterManager.Instance.BackgroundRotation);
if (ParameterManager.Instance.Version == ParameterManager.BuildVersion.COMPLETE)
{
SetExitButton(false);
}
else
{
SetExitButton(true);
}
}
else
{
SetExitButton(true);
}
if (Application.platform != RuntimePlatform.WebGLPlayer)
{
offlineExperimentButton.interactable = true;
completeExperimentButton.interactable = true;
directoryButton.interactable = true;
downloadAllButton.interactable = true;
downloadDirectory = Application.persistentDataPath + "/Downloads";
if (!Directory.Exists(downloadDirectory))
{
Directory.CreateDirectory(downloadDirectory);
}
}
}
/// <summary>
/// 测试初始化
/// </summary>
public WhereClauseTest()
{
_parameterManager = new ParameterManager(new OracleDialect());
_database = new TestTableDatabase();
_builder = new SqlServerBuilder(new TestEntityMatedata(), null, _parameterManager);
_clause = new WhereClause(_builder, new OracleDialect(), new EntityResolver(), new EntityAliasRegister(), _parameterManager);
}
public void Test_ParameterManager_SimpleRename()
{
var p1 = new ConstantParameter("DECLARE @fish as int", "1", "fishes be here", new MicrosoftQuerySyntaxHelper());
var p2 = new ConstantParameter("DECLARE @fish as int", "2", "fishes be here", new MicrosoftQuerySyntaxHelper());
var pm1 = new ParameterManager();
var pm2 = new ParameterManager();
var pm3 = new ParameterManager();
pm1.ParametersFoundSoFarInQueryGeneration[ParameterLevel.QueryLevel].Add(p1);
pm2.ParametersFoundSoFarInQueryGeneration[ParameterLevel.QueryLevel].Add(p2);
pm3.ImportAndElevateResolvedParametersFromSubquery(pm1, out Dictionary <string, string> renames1);
pm3.ImportAndElevateResolvedParametersFromSubquery(pm2, out Dictionary <string, string> renames2);
var final = pm3.GetFinalResolvedParametersList().ToArray();
//the final composite parameters should have a rename in them
Assert.AreEqual("@fish", final[0].ParameterName);
Assert.AreEqual("@fish_2", final[1].ParameterName);
Assert.IsEmpty(renames1);
Assert.AreEqual("@fish", renames2.Single().Key);
Assert.AreEqual("@fish_2", renames2.Single().Value);
}
public Step CreateInstance(ParameterManager processParameterManager)
{
var step = new Step(OwnerProcess, Name, StepId, NextStep)
{
OwnerProcessInstance = OwnerProcessInstance,
InParameterBinds = InParameterBinds.Select(inParameterBind => inParameterBind.CreateParameterBind())
.ToList(),
OutParameterBinds = OutParameterBinds.Select(outParameterBind => outParameterBind.CreateParameterBind())
.ToList(),
StepAction = StepAction.Create(processParameterManager),
_msPerTicket = _msPerTicket,
_waitTicks = _waitTicks
};
var showParameters = ShowParameters.ToList();
var stepChecks = _stepChecks.Select(stepCheck => stepCheck.Create(this)).ToList();
step.ShowParameters = showParameters;
if (stepChecks.Count > 0)
{
step._stepChecks = stepChecks;
}
return(step);
}
//=============================================================
private void Init()
{
text = transform.Find("Text").GetComponent <Text>();
image = transform.Find("Image").GetComponent <Image>();
parameterManager = GameObject.Find("ParameterManager").GetComponent <ParameterManager>();
gameManager = GameObject.Find("GameManager").GetComponent <GameManager>();
}
public string CheckGroup(string domain, string username)
{
string Resultgroup = string.Empty, groups = string.Empty;
groups = GetGroups(username, domain);
if (groups.Contains(Admin.Trim()))
{
Resultgroup = Constants.UserGroups.Admin;
}
else if (groups.Contains(Checker.Trim()))
{
Resultgroup = Constants.UserGroups.Checker;
}
else if (groups.Contains(Maker.Trim()))
{
Resultgroup = Constants.UserGroups.Maker;
}
else if (groups.Contains(ParameterManager.Trim()))
{
Resultgroup = Constants.UserGroups.ParameterManager;
}
else if (groups.Contains(ApplicationUser.Trim()))
{
Resultgroup = Constants.UserGroups.ApplicationUserManagement;
}
else
{
Resultgroup = string.Empty;
}
return(Resultgroup);
}
async void RegisterCommandAsync()
{
if (!string.IsNullOrEmpty(_username) && !string.IsNullOrEmpty(_password) && !string.IsNullOrEmpty(_email))
{
if (_email.Contains("@") && _email.Contains("."))
{
if (_password.Equals(_passwordConfirm))
{
using (UserDialogs.Instance.Loading(CommonResource.Login_RegistrationProcess, null, null, true, MaskType.Black))
{
AccountApiRequest apiRequest = new AccountApiRequest(_apiUrl);
Analytics.TrackEvent("Register user started", new Dictionary <string, string> {
{ "Username", _username }
});
TokenResponse authData = await apiRequest.RegisterNewUserAsync(_username, _password, _email);
if (!string.IsNullOrEmpty(authData?.Access_Token))
{
Analytics.TrackEvent("Register new user done", new Dictionary <string, string> {
{ "Username", _username }
});
TokenStoreService tokenService = new TokenStoreService();
if (await tokenService.SetAuthDataAsync(authData.Access_Token, authData.UserId, _username, _email))
{
ParameterManager par = new ParameterManager();
par.Set("GuestMode", "0");
Xamarin.Forms.MessagingCenter.Send <AuthResultMessage>(new AuthResultMessage()
{
IsAuthenticated = true, Username = _username
}, string.Empty);
#if !DEBUG
Xamarin.Forms.MessagingCenter.Send <SyncMessage>(new SyncMessage(), string.Empty);
#endif
await Navigation.PopModalAsync();
}
}
else
{
Analytics.TrackEvent("Register new user error", new Dictionary <string, string> {
{ "Username", _username }
});
await Application.Current.MainPage.DisplayAlert(CommonResource.CommonMsg_Warning, CommonResource.Login_RegistrationError, "Ok");
}
}
}
else
{
await Application.Current.MainPage.DisplayAlert(CommonResource.CommonMsg_Warning, CommonResource.Login_EnterSamePasswords, "Ok");
}
}
else
{
await Application.Current.MainPage.DisplayAlert(CommonResource.CommonMsg_Warning, CommonResource.Login_EnterCorrectEmail, "Ok");
}
}
else
{
await Application.Current.MainPage.DisplayAlert(CommonResource.CommonMsg_Warning, CommonResource.Login_FillAllFields, "Ok");
}
}
/// <summary>
/// パラメータに初期値を入れる。
/// </summary>
public void RestoreDefaultParameters()
{
for (int index = 0; index < ParameterCount; index++)
{
ParameterValues[index] = (float)ParameterManager.GetId(index).Default;
}
}
public RedistributionFilter(string filterName)
{
// set class version
base.CLASS_VERSION = CLASS_VERSION;
// store the filter name
this.filterName = filterName;
// initialize the logger and parameters with the filter name
logger = LogManager.GetLogger(filterName);
parameters = ParameterManager.GetParameters(filterName, Parameters.ParamSetTypes.Filter);
// define the parameters
parameters.addParameter <bool>(
"EnableFilter",
"Enable filter",
"1");
parameters.addParameter <bool>(
"LogDataStreams",
"Log the filter's intermediate and output data streams. See 'Data' tab for more settings on sample stream logging.",
"0");
parameters.addParameter <double[][]> (
"Redistribution",
"Specifies which input channels are added together to one or more output channels.\nAlso specifies which weights are applied to the input values before addition\n\nInput: Input channel (1...n)\nOutput: output channel (1...n)\nWeight: Weight applied to input channel value",
"", "", "1,2;1,2;1,1", new string[] { "Input", "Output", "Weight" });
// message
logger.Info("Filter created (version " + CLASS_VERSION + ")");
}
private string BuildSql(CohortQueryBuilderDependency dependency, ParameterManager parameterManager)
{
//if we are fully cached on everything
if (dependency.SqlFullyCached != null)
{
SetTargetServer(GetCacheServer(), " dependency is cached"); //run on the cache server
CountOfCachedSubQueries++; //it is cached
return(dependency.SqlFullyCached.Use(parameterManager)); //run the fully cached sql
}
switch (CacheUsageDecision)
{
case CacheUsage.MustUse:
throw new QueryBuildingException("Could not build final SQL because " + dependency + " is not fully cached and CacheUsageDecision is " + CacheUsageDecision);
case CacheUsage.Opportunistic:
//The cache and dataset are on the same server so run it
SetTargetServer(DependenciesSingleServer.GetDistinctServer(), "data and cache are on the same server");
return(dependency.SqlPartiallyCached?.Use(parameterManager) ?? dependency.SqlCacheless.Use(parameterManager));
case CacheUsage.AllOrNothing:
//It's not fully cached so we have to run it entirely uncached
SetTargetServer(DependenciesSingleServer.GetDistinctServer(), "cache and data are on seperate servers / access credentials and not all datasets are in the cache");
return(dependency.SqlCacheless.Use(parameterManager));
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task <string> TryGetGuestTokenAsync()
{
string token = string.Empty;
ParameterManager par = new ParameterManager();
string demoUsername = generateDemoUsername();
par.Set("DemoUsername", demoUsername);
AccountApiRequest apiRequest = new AccountApiRequest(_apiUrl);
_username = demoUsername;
_password = demoUsername;
TokenResponse authData = await apiRequest.GetTokenAsync(_username, _password, true);
if (!string.IsNullOrEmpty(authData?.Access_Token))
{
Analytics.TrackEvent("GetToken Demo", new Dictionary <string, string> {
{ "Username", _username }
});
TokenStoreService tokenService = new TokenStoreService();
bool setResultIsOk = await tokenService.SetAuthDataAsync(authData.Access_Token, authData.UserId, string.Empty, string.Empty);
if (setResultIsOk)
{
token = authData.Access_Token;
}
}
return(token);
}
public CoordControl(IMainWindow _window)
{
InitializeComponent();
this.window = _window;
this.parameterManager = window.ParameterManager;
}
public void BuildFor(CohortAggregateContainer container, ParameterManager parameterManager)
{
ThrowIfAlreadyBuilt();
IsForContainer = true;
_log.AppendLine("Starting Build for " + container);
//gather dependencies
foreach (var cohortSet in ChildProvider.GetAllChildrenRecursively(container).OfType <AggregateConfiguration>().Where(IsEnabled).OrderBy(ac => ac.Order))
{
AddDependency(cohortSet);
}
if (!Dependencies.Any())
{
throw new QueryBuildingException($"There are no AggregateConfigurations under the SET container '{container}'");
}
LogDependencies();
BuildDependenciesSql(parameterManager.ParametersFoundSoFarInQueryGeneration[ParameterLevel.Global].ToArray());
MakeCacheDecision();
Sql = BuildSql(container, parameterManager);
}
public ParameterCollectionUIOptions Create(TableInfo tableInfo)
{
var pm = new ParameterManager();
pm.AddParametersFor(tableInfo);
return(new ParameterCollectionUIOptions(UseCaseTableInfo, tableInfo, ParameterLevel.TableInfo, pm));
}
public bool ResetAuthToken()
{
try
{
SecureStorage.Remove(_tokenNameKey);
SecureStorage.Remove(_userIdKey);
SecureStorage.Remove(_tokenUsernameKey);
SecureStorage.Remove(_tokenEmailKey);
SecureStorage.Remove(_tokenImgUrlKey);
SecureStorage.Remove(_tokenRoleKey);
}
catch (Exception e)
{
HandleError.Process("TokenStoreService", "ResetAuthTokenAsync", e, false);
ParameterManager par = new ParameterManager();
par.Delete(_tokenNameKey);
par.Delete(_userIdKey);
par.Delete(_tokenUsernameKey);
par.Delete(_tokenEmailKey);
par.Delete(_tokenImgUrlKey);
par.Delete(_tokenRoleKey);
}
return(true);
}
public MainWindow()
{
InitializeComponent();
string[] args = Environment.GetCommandLineArgs();
if (args.Length < 2)
{
MessageBox.Show("you have to open a scene, a mesh, a model, a material or a shader");
Application.Current.Shutdown();
return;
}
Logger.Init();
Logger.OnLog += Logger_OnLog;
string filePath = args[1];
graphics = new Graphics();
graphics.Init();
audio = new Audio();
parameterManager = new ParameterManager();
timer = new Timer();
scriptEngine = new ScriptEngine();
scriptEngine.Init(timer);
physics = new Physics();
physics.Init();
resourceManager = new ResourceManager();
resourceContext = new ResourceContext(graphics, audio, parameterManager, scriptEngine, physics, resourceManager);
parameterManager.InitDefaultTextures(resourceContext);
sceneView.Init(resourceContext);
loadFile(filePath);
}
/// <summary>
/// Build a query based on the current <see cref="AggregateConfiguration"/>
/// </summary>
/// <param name="limitationSQL">See <see cref="LimitationSQL"/></param>
/// <param name="countSQL">
/// Intended purpose:The line of SELECT Sql that is an 'Aggregate Function' e.g. count(*).
/// <para>Other purposes: You can use this to ram arbitrary lines of code into SELECT section of the query e.g. see CohortQueryBuilder </para>
/// </param>
/// <param name="aggregateConfigurationIfAny"><see cref="AggregateConfiguration"/> containing columns, filters, parameters etc for the GROUP BY</param>
public AggregateBuilder(string limitationSQL, string countSQL, AggregateConfiguration aggregateConfigurationIfAny)
{
if (limitationSQL != null && limitationSQL.Trim().StartsWith("top", StringComparison.CurrentCultureIgnoreCase))
{
throw new Exception("Use AggregateTopX property instead of limitation SQL to acheive this");
}
_aggregateConfigurationIfAny = aggregateConfigurationIfAny;
LimitationSQL = limitationSQL;
ParameterManager = new ParameterManager();
CustomLines = new List <CustomLine>();
SQLOutOfDate = true;
SelectColumns = new List <QueryTimeColumn>();
if (!string.IsNullOrWhiteSpace(countSQL))
{
_countColumn = new AggregateCountColumn(countSQL);
_countColumn.Order = int.MaxValue;//order these last
AddColumn(_countColumn);
}
LabelWithComment = aggregateConfigurationIfAny != null ? aggregateConfigurationIfAny.Name : "";
_queryLevelParameterProvider = aggregateConfigurationIfAny;
if (aggregateConfigurationIfAny != null)
{
HavingSQL = aggregateConfigurationIfAny.HavingSQL;
AggregateTopX = aggregateConfigurationIfAny.GetTopXIfAny();
}
}
private int[] mDirections = null; // the direction in which the threshold is applied
public ThresholdClassifierFilter(string filterName)
{
// set class version
base.CLASS_VERSION = CLASS_VERSION;
// store the filter name
this.filterName = filterName;
// initialize the logger and parameters with the filter name
logger = LogManager.GetLogger(filterName);
parameters = ParameterManager.GetParameters(filterName, Parameters.ParamSetTypes.Filter);
// define the parameters
parameters.addParameter <bool>(
"EnableFilter",
"Enable threshold classifier filter",
"1");
parameters.addParameter <bool>(
"LogDataStreams",
"Log the filter's intermediate and output data streams. See 'Data' tab for more settings on sample stream logging.",
"0");
parameters.addParameter <double[][]> (
"Thresholding",
"Specifies which channels are thresholded, the other channels pass through untouched.\n\nChannel: the channel (1...n) to which thresholding will be applied.\nThreshold: the threshold above (>) or under (<) which the channel output will become 1 or 0\nDirection: the direction of the thresholding. If the direction value is negative (<0) then input values smaller than\nthe threshold will result in true; if positive (>= 0) then input values larger than the threshold will result in true.",
"", "", "1,2;0.45,0.45;1,1", new string[] { "Channel", "Threshold", "Direction" });
// message
logger.Info("Filter created (version " + CLASS_VERSION + ")");
}
public string SaveAliasPurelyRandom()
{
string textFilePath = Application.persistentDataPath;
ParameterManager pMan = ParameterManager.Instance;
string returnString = "";
if (textFilePath == null && !Directory.Exists(textFilePath))
{
ErrorManager.ManageError(ErrorManager.Error.SOFT_ERROR, "Error while retrieving the folder, please insert a " + "valid path.");
}
else
{
try
{
string textMap = "";
textMap += objectiveFunctionName() + "\n";
foreach (var v in graphPlot)
{
textMap += v.Item2.ToString(new CultureInfo("en-US")) + "\n";
}
string fileName = "Opt" + pMan.optimizerType + "BestP" + (pMan.isBestPathOnlyExplorative ? 0 : pMan.onlyBestPath ? 1 : 2) + "-" + pMan.MapToPlay.GetLength(0) + "x" + pMan.MapToPlay.GetLength(1) + "_" + pMan.aliasNum + "_" + pMan.hillClimberNumBatch + "@" + graphPlot.Count + "PURELYRANDOM" + $@"{DateTime.Now.Ticks}" + ".csv";
File.WriteAllText(@textFilePath + "/" + fileName, textMap);
returnString = "\n" + "Optimization values \"" + fileName + "\" successfully saved at:\n" + textFilePath;
}
catch (Exception)
{
ErrorManager.ManageError(ErrorManager.Error.SOFT_ERROR, "Error while saving the map at " + @textFilePath + ", please insert a valid path and check its permissions. ");
}
}
return(returnString);
}
public async void StartDialog()
{
PermissionManager permissions = new PermissionManager();
var taskPermissionRead = await permissions.CheckAndRequestStorageReadPermission();
if (taskPermissionRead.HasFlag(Xamarin.Essentials.PermissionStatus.Granted))
{
ImagesCacheDbManager imagesCache = new ImagesCacheDbManager(new ImageManager(), DateTime.Now.AddDays(90), DateTime.Now);
ParameterManager parameterManager = new ParameterManager();
_initDCIMDirectory = string.Empty;
if (!parameterManager.Get("CameraDirectoryFullPath", out _initDCIMDirectory))
{
//параметр заполняется при старте индексации, уже должен быть заполнен
_initDCIMDirectory = imagesCache.GetPublicDirectoryDcim();
}
PathToDefaultDCIM = imagesCache.GetPublicDirectoryDcim();
PathToCustomDCIM = _initDCIMDirectory;
IsUsageMainMemory = _initDCIMDirectory.Equals(PathToDefaultDCIM);
await Task.Run(() =>
{
MediaFileManager mediaFileManager = new MediaFileManager();
CountOfPhotoDefaultDCIM = mediaFileManager.GetMediaFilesFromDirectory(new DirectoryInfo(PathToDefaultDCIM)).Count();
_pathToImagesDir = _initDCIMDirectory;
CountOfPhotoCustomDCIM = mediaFileManager.GetMediaFilesFromDirectory(new DirectoryInfo(_initDCIMDirectory)).Count();
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("CountOfPhotoDefaultDCIM"));
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("CountOfPhotoCustomDCIM"));
updateDirContent(new DirectoryInfo(_pathToImagesDir));
});
}
}
private bool[] activeState = null; // whether a specific channel is open to clicks (true/active = open to click, false = in refractory period)
public ClickTranslatorFilter(string filterName)
{
// set class version
base.CLASS_VERSION = CLASS_VERSION;
// store the filter name
this.filterName = filterName;
// initialize the logger and parameters with the filter name
logger = LogManager.GetLogger(filterName);
parameters = ParameterManager.GetParameters(filterName, Parameters.ParamSetTypes.Filter);
// define the parameters
parameters.addParameter <bool>(
"EnableFilter",
"Enable click translator filter",
"1");
parameters.addParameter <bool>(
"LogDataStreams",
"Log the filter's intermediate and output data streams. See 'Data' tab for more settings on sample stream logging.",
"0");
parameters.addParameter <double[][]>(
"Translators",
"Specifies which channels are click-translated, the other channels pass through untouched.\n\nChannel: the channel (1...n) to which click-translation will be applied.\nActivePeriod: Time window of buffer used for determining clicks (in samples or seconds).\nActiveRateThreshold: The threshold above which the average value (of ActivePeriod) in active state should get to send a 'click' and put the channel into inactive state.\nRefractoryPeriod: Time window after click in which no click will be translated (in samples or seconds).",
"", "", "1,2;0.4s,0.4s;0.5,0.5;3.6s,3.6s", new string[] { "Channel", "ActivePeriod", "ActiveRateThreshold", "RefractoryPeriod" });
// message
logger.Info("Filter created (version " + CLASS_VERSION + ")");
}
public override void ManageMap(bool assembleMap)
{
if (loadMapFromFile)
{
// Load the map.
LoadMapFromText();
// Flip the map if needed.
if (flip)
{
map = MapEdit.FlipMap(map);
}
}
else
{
// Generate the map.
if (ParameterManager.HasInstance())
{
map = mapGeneratorScript.GenerateMap(seed, export, exportPath);
}
else
{
map = mapGeneratorScript.GenerateMap();
}
}
if (assembleMap)
{
// Assemble the map.
mapAssemblerScript.AssembleMap(map, mapGeneratorScript.GetWallChar(),
mapGeneratorScript.GetRoomChar());
// Displace the objects.
objectDisplacerScript.DisplaceObjects(map, mapAssemblerScript.GetSquareSize(),
mapAssemblerScript.GetWallHeight());
}
}
public ParameterCollectionUIOptions Create(ExtractionFilterParameterSet parameterSet)
{
var pm = new ParameterManager();
pm.ParametersFoundSoFarInQueryGeneration[ParameterLevel.TableInfo].AddRange(parameterSet.Values);
return(new ParameterCollectionUIOptions(UseCaseParameterValueSet, parameterSet, ParameterLevel.TableInfo, pm));
}
public void SetupTest()
{
_paramMgr = new ParameterManager( _nameGenerator, _parameterNamesJoiner, _parameterStubFactory );
_returnedParamName = _paramMgr.AddParameter( _inputParamValue, _inputDbType );
_expectedResults = new List<IParameterStub> { _parameterStub };
_results = _paramMgr.GetParameterStubs();
}
public void SetupTest()
{
_paramMgr = new ParameterManager( _nameFactory, _parameterNamesJoiner, _parameterStubFactory );
_paramMgr.AddParameter( _inputParamValue0 );
_paramMgr.AddParameter( _inputParamValue1 );
_paramMgr.AddParameter( _inputParamValue2 );
_paramMgr.AddParameter( _inputEnumParam );
_results = _paramMgr.GetParameterStubs();
}
public void SetupTest()
{
_paramMgr = new ParameterManager( _nameGenerator, _parameterNamesJoiner, _parameterStubFactory );
_results = _paramMgr.GetParameterStubs();
}
