//used for loading items?
private async Task ExecuteLoadDataCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
DatasetItem.Clear();
var dataset = await DataStore.GetAllAsync_Item(true);
foreach (var data in dataset)
{
DatasetItem.Add(data);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public override void Execute(ImportInput input)
{
var foundDateset = dataSetRepo.Get(input.DataSetId);
var itemsSourcePath = Path.Join(input.FolderPath, "original images");
foundDateset.ItemsSourcePath = itemsSourcePath;
var processedPath = Path.Join(input.FolderPath, "processed_images");
foundDateset.ProcessedItemsSourcePath = processedPath;
var allProcessedfiles = Directory.GetFiles(processedPath, "*.*", SearchOption.AllDirectories);
foreach (var file in allProcessedfiles)
{
var fileInfo = new FileInfo(file);
var item = new DatasetItem();
item.DatasetID = input.DataSetId;
item.Name = fileInfo.Name;
item.FilePath = fileInfo.FullName;
item.FileName = fileInfo.Name;
item.LabelId = GetOrCreateLabelId(foundDateset.Id, fileInfo.Directory.Name);
item.FileExtension = Path.GetExtension(fileInfo.FullName);
item.FileSize = fileInfo.Length;
itemRepo.Insert(item);
}
CurrentUnitOfWork.SaveChanges();
}
private void AddRulesCoordinatesToDomain(
Dictionary <string, int> domainCounts,
Dictionary <string, Dictionary <PatternRule, int> > ruleCountsForDomains,
Dictionary <string, Dictionary <PatternRule, HashSet <PatternMiningCoordinates> > > domainsToRulesToCoordinates,
string domain,
List <PatternRule> rules,
DatasetItem gtItem,
int pruneIntervalCount,
int pruneMinKeepThreshold)
{
if (
domainsToRulesToCoordinates == null ||
string.IsNullOrWhiteSpace(domain) ||
rules == null ||
rules.Count == 0 ||
gtItem == null)
{
return;
}
var rulesToCoordinates = this.RetrieveRulesToCoordinatesSet(domainsToRulesToCoordinates, domain);
var newCoordinates = new PatternMiningCoordinates()
{
Latitude = gtItem.Latitude,
Longitude = gtItem.Longitude,
Confidence = 0d
};
var rulesCountsForDomain = this.AddRetrieveDomainToRulesCounts(ruleCountsForDomains, domain);
foreach (var rule in rules)
{
this.IncrementOccurrences(rulesCountsForDomain, rule);
HashSet <PatternMiningCoordinates> coordinatesForRule;
if (!rulesToCoordinates.TryGetValue(rule, out coordinatesForRule))
{
coordinatesForRule = new HashSet <PatternMiningCoordinates>();
rulesToCoordinates[rule] = coordinatesForRule;
}
coordinatesForRule.Add(newCoordinates);
}
var domainOcc = this.IncrementOccurrences(domainCounts, domain);
if (domainOcc % pruneIntervalCount == 0)
{
this.PruneCounts(rulesCountsForDomain, rulesToCoordinates, minKeepThreshold: pruneMinKeepThreshold);
}
}
internal void AddData(DatasetItem dsItem)
{
if (!_open &&
dsItem != null &&
dsItem.Dataset != null &&
dsItem.TargetName != null)
{
cmbData.Items.Add(dsItem);
if (dsItem != null)
{
cmbData.SelectedItem = dsItem;
}
}
}
private void SetQuestionInfo(QuestionDto question, Dataset dataSet, DatasetItem dataSetItem)
{
question.QuestionSubjectFileSrc = dataSetItem.Id.ToString();
if (question.QuestionType == QuestionType.Text)
{
if (dataSet.QuestionTemplate.IsNullOrEmpty())
{
throw new UserFriendlyException("Question template of dataset is empty");
}
//if (!dataSet.QuestionTemplate.Contains("{{Label.Title}}"))
// throw new UserFriendlyException("Question template does not have {{Label.Title}} placeholder (case sensitive).");
// TODO: CHANGE TO LABEL NAME
var label = labelRepo.Get(dataSetItem.LabelId.Value);
question.Title = dataSet.QuestionTemplate.Replace("{{Label.Title}}", label.Name);
}
if (question.QuestionType == QuestionType.Image || question.QuestionType == QuestionType.Video || question.QuestionType == QuestionType.Voice)
{
question.QuestionFileSrc = dataSet.QuestionSrc;
}
}
public DbscanPoint(DatasetItem x)
{
ClusterPoint = x;
IsVisited = false;
ClusterId = (int)ClusterIds.UNCLASSIFIED;
}
private void RegionQuery(DbscanPoint[] allPoints, DatasetItem p, double epsilon, out DbscanPoint[] neighborPts)
{
neighborPts = allPoints.Where(x => _metricFunc(p, x.ClusterPoint) <= epsilon).ToArray();
}
private void AddRulesCoordinatesToDomain(
Dictionary <string, int> domainCounts,
Dictionary <string, Dictionary <PatternRule, int> > ruleCountsForDomains,
Dictionary <string, Dictionary <PatternRule, Dictionary <Coord, int> > > domainsToRulesToCoordinateCounts,
string domain,
List <PatternRule> rules,
DatasetItem gtItem,
int pruneIntervalCount,
int pruneMinKeepThreshold)
{
if (
domainsToRulesToCoordinateCounts == null ||
string.IsNullOrWhiteSpace(domain) ||
rules == null ||
rules.Count == 0 ||
gtItem == null)
{
return;
}
var rulesToCoordinateCounts = this.RetrieveRulesToCoordinateCounts(domainsToRulesToCoordinateCounts, domain);
// https://gis.stackexchange.com/questions/8650/measuring-accuracy-of-latitude-and-longitude
var newCoordinates = new Coord()
{
Latitude = Math.Round(gtItem.Latitude, 2),
Longitude = Math.Round(gtItem.Longitude, 2)
};
var ruleCountsForDomain = this.AddRetrieveDomainToRuleCounts(ruleCountsForDomains, domain);
foreach (var rule in rules)
{
this.IncrementOccurrences(ruleCountsForDomain, rule);
Dictionary <Coord, int> coordinateCountsForRule;
if (!rulesToCoordinateCounts.TryGetValue(rule, out coordinateCountsForRule))
{
coordinateCountsForRule = new Dictionary <Coord, int>();
rulesToCoordinateCounts[rule] = coordinateCountsForRule;
}
int currentCount;
if (!coordinateCountsForRule.TryGetValue(newCoordinates, out currentCount))
{
currentCount = 0;
}
coordinateCountsForRule[newCoordinates] = currentCount + 1;
}
var domainOcc = this.IncrementOccurrences(domainCounts, domain);
/*
* private void PruneCounts(
* Dictionary<string, int> domainCounts,
* Dictionary<string, Dictionary<PatternRule, int>> ruleCountsForDomains,
* Dictionary<string, Dictionary<PatternRule, Dictionary<Coord, int>>> domainsToRulesToCoordinateCounts,
* string domain,
* int minKeepThreshold)
*/
if (domainOcc % pruneIntervalCount == 0)
{
Console.WriteLine();
Console.WriteLine($"Before pruning domain {domain} we had {ruleCountsForDomain.Count} rules");
this.PruneCounts(ruleCountsForDomains, domainsToRulesToCoordinateCounts, domain, minKeepThreshold: pruneMinKeepThreshold);
Console.WriteLine($"After pruning domain {domain} we had {ruleCountsForDomain.Count} rules");
Console.WriteLine();
}
}
private void btnAdd_Click(object sender, EventArgs e)
{
List <ExplorerDialogFilter> filters = new List <ExplorerDialogFilter>();
if (_open)
{
filters.Add(new OpenActivityDataFilter(_aData));
}
else
{
filters = SaveFeatureClassFilters.AllFilters;
}
ExplorerDialog dlg = new ExplorerDialog(gbDataName.Text,
filters,
_open);
if (dlg.ShowDialog() == DialogResult.OK &&
dlg.ExplorerObjects != null &&
dlg.ExplorerObjects.Count > 0)
{
object item = null;
foreach (IExplorerObject exObject in dlg.ExplorerObjects)
{
if (exObject == null)
{
continue;
}
if (_open) // Source
{
if (exObject.Object is IDatasetElement)
{
item = new DatasetElementItem((IDatasetElement)exObject.Object);
cmbData.Items.Add(item);
}
else if (exObject.Object is IClass)
{
item = new DatasetElementItem(new DatasetElement((IClass)exObject.Object));
cmbData.Items.Add(item);
}
}
else // Target
{
if (exObject.Object is IDataset &&
!String.IsNullOrEmpty(dlg.TargetName))
{
item = new DatasetItem((IDataset)exObject.Object, dlg.TargetName);
cmbData.Items.Add(item);
}
else if (dlg.SelectedExplorerDialogFilter != null &&
dlg.SelectedExplorerDialogFilter.FilterObject is IFeatureDataset &&
!String.IsNullOrEmpty(dlg.TargetName))
{
IFileFeatureDatabase fileDB = (IFileFeatureDatabase)((IFeatureDataset)dlg.SelectedExplorerDialogFilter.FilterObject).Database;
IFeatureDataset ds = fileDB[exObject.FullName];
if (ds != null)
{
item = new DatasetItem(ds, dlg.TargetName);
cmbData.Items.Add(item);
}
}
}
}
// letztes eingefügtes auswählen
if (item != null)
{
cmbData.SelectedItem = item;
}
}
}
