public DuplicatesDetectorService(IModelService modelService, IAudioService audioService, IFingerprintCommandBuilder fingerprintCommandBuilder, IQueryFingerprintService queryFingerprintService)
{
this.modelService = modelService;
this.audioService = audioService;
this.fingerprintCommandBuilder = fingerprintCommandBuilder;
this.queryFingerprintService = queryFingerprintService;
}
public CustomerListViewModel(IUnityContainer container)
{
this.container = container;
this.logger = this.container.Resolve<ILoggerFacade>();
this.eventAggregator = this.container.Resolve<IEventAggregator>();
this.modelService = this.container.Resolve<IModelService>();
}
public WinEnsembleHash(IFingerprintService fingerprintService, IModelService modelService)
{
this.modelService = modelService;
InitializeComponent();
Icon = Resources.Sound;
new DatabasePermutations(modelService);
}
/// <summary>
/// Initializes a new instance of the <see cref="PullRequestDetailViewModel"/> class.
/// </summary>
/// <param name="repositoryHost">The repository host.</param>
/// <param name="teservice">The team explorer service.</param>
/// <param name="pullRequestsService">The pull requests service.</param>
/// <param name="avatarProvider">The avatar provider.</param>
public PullRequestDetailViewModel(
ILocalRepositoryModel repository,
IModelService modelService,
IPullRequestService pullRequestsService,
IPackageSettings settings)
{
this.repository = repository;
this.modelService = modelService;
this.pullRequestsService = pullRequestsService;
Checkout = ReactiveCommand.CreateAsyncObservable(
this.WhenAnyValue(x => x.CheckoutState)
.Cast<CheckoutCommandState>()
.Select(x => x != null && x.DisabledMessage == null),
DoCheckout);
Checkout.ThrownExceptions.Subscribe(x => OperationError = x.Message);
Pull = ReactiveCommand.CreateAsyncObservable(
this.WhenAnyValue(x => x.UpdateState)
.Cast<UpdateCommandState>()
.Select(x => x != null && x.PullDisabledMessage == null),
DoPull);
Pull.ThrownExceptions.Subscribe(x => OperationError = x.Message);
Push = ReactiveCommand.CreateAsyncObservable(
this.WhenAnyValue(x => x.UpdateState)
.Cast<UpdateCommandState>()
.Select(x => x != null && x.PushDisabledMessage == null),
DoPush);
Push.ThrownExceptions.Subscribe(x => OperationError = x.Message);
OpenOnGitHub = ReactiveCommand.Create();
ChangedFilesViewType = (settings.UIState?.PullRequestDetailState?.ShowTree ?? true) ?
ChangedFilesViewType.TreeView : ChangedFilesViewType.ListView;
ToggleChangedFilesView = ReactiveCommand.Create();
ToggleChangedFilesView.Subscribe(_ =>
{
ChangedFilesViewType = ChangedFilesViewType == ChangedFilesViewType.TreeView ?
ChangedFilesViewType.ListView : ChangedFilesViewType.TreeView;
settings.UIState.PullRequestDetailState.ShowTree = ChangedFilesViewType == ChangedFilesViewType.TreeView;
settings.Save();
});
OpenChangedFileAction = (settings.UIState?.PullRequestDetailState?.DiffOnOpen ?? true) ?
OpenChangedFileAction.Diff : OpenChangedFileAction.Open;
ToggleOpenChangedFileAction = ReactiveCommand.Create();
ToggleOpenChangedFileAction.Subscribe(_ =>
{
OpenChangedFileAction = OpenChangedFileAction == OpenChangedFileAction.Diff ?
OpenChangedFileAction.Open : OpenChangedFileAction.Diff;
settings.UIState.PullRequestDetailState.DiffOnOpen = OpenChangedFileAction == OpenChangedFileAction.Diff;
settings.Save();
});
OpenFile = ReactiveCommand.Create();
DiffFile = ReactiveCommand.Create();
}
public QueryResult QueryWithTimeSequenceInformation(IModelService modelService, IEnumerable<HashedFingerprint> hashedFingerprints, QueryConfiguration queryConfiguration)
{
var allCandidates = GetAllCandidates(modelService, hashedFingerprints, queryConfiguration);
if (!allCandidates.Any())
{
return NoResult;
}
var entries = this.GetCandidatesSortedByLCS(allCandidates);
var resultEntries = entries
.Take(queryConfiguration.MaximumNumberOfTracksToReturnAsResult)
.Select(datas => new ResultEntry
{
Track = modelService.ReadTrackByReference(datas.First().TrackReference),
Similarity = datas.Count(),
SequenceStart = datas.First().SequenceAt,
SequenceLength = datas.Last().SequenceAt - datas.First().SequenceAt + 1.48d // TODO 1.48 because of default fingerprint config. For other configurations there is going to be equal to Overlap * ImageLength / SampleRate
})
.ToList();
var returnresult = new QueryResult
{
IsSuccessful = true,
ResultEntries = resultEntries,
AnalyzedCandidatesCount = allCandidates.Count
};
return returnresult;
}
public IQueryCommand UsingServices(IModelService modelService, IAudioService audioService)
{
this.modelService = modelService;
createFingerprintMethod = () => fingerprintingMethodFromSelector()
.WithFingerprintConfig(FingerprintConfiguration)
.UsingServices(audioService);
return this;
}
public LoginModule(ILogger logger, IModelService<UserModel> users, IRavenRepository<SessionModel> sessions)
{
_logger = logger;
_users = users;
_sessions = sessions;
Post["/login"] = x => Login();
Get["/logout"] = x => Logout();
}
public EmployeesViewModel(IUnityContainer container)
{
this.container = container;
this.logger = this.container.Resolve<ILoggerFacade>();
this.eventAggregator = this.container.Resolve<IEventAggregator>();
this.modelService = this.container.Resolve<IModelService>();
SubmitCommand = new DelegateCommand(this.OnSubmit);
}
public ProductController(IProductService productService, ISizeService sizeService, ITypeService typeService, IOriginService originService, IModelService modelService)
{
_productService = productService;
_sizeService = sizeService;
_typeService = typeService;
_originService = originService;
_modelService = modelService;
}
public CacheModule(IModelService<ImageModel> images, IModelService<CacheModel> caches, IDocumentStore documentStore)
{
_images = images;
_caches = caches;
_documentStore = documentStore;
Post["/cache"] = x => CreateCache();
Get["/caches"] = x => GetCaches();
Get["/cache/{id}"] = x => GetCache(x.id);
}
private IEnumerable<SubFingerprintData> GetSubFingerprints(IModelService modelService, HashData hash, IQueryConfiguration queryConfiguration)
{
if (!string.IsNullOrEmpty(queryConfiguration.TrackGroupId))
{
return modelService.ReadSubFingerprintDataByHashBucketsThresholdWithGroupId(hash.HashBins, queryConfiguration.ThresholdVotes, queryConfiguration.TrackGroupId);
}
return modelService.ReadSubFingerprintDataByHashBucketsWithThreshold(hash.HashBins, queryConfiguration.ThresholdVotes);
}
private ConcurrentDictionary<IModelReference, ResultEntryAccumulator> GetSimilaritiesUsingNonBatchedStrategy(IEnumerable<HashedFingerprint> queryFingerprints, QueryConfiguration configuration, IModelService modelService)
{
var hammingSimilarities = new ConcurrentDictionary<IModelReference, ResultEntryAccumulator>();
foreach (var queryFingerprint in queryFingerprints)
{
var subFingerprints = modelService.ReadSubFingerprints(queryFingerprint.HashBins, configuration);
similarityUtility.AccumulateHammingSimilarity(subFingerprints, queryFingerprint, hammingSimilarities);
}
return hammingSimilarities;
}
public NetTrainer(IModelService modelService)
{
Network net = new Network();
net.AddLayer(new BasicLayer(new ActivationTANH(), true, DefaultFingerprintSize));
net.AddLayer(new BasicLayer(new ActivationTANH(), true, DefaultHiddenNeuronsCount));
net.AddLayer(new BasicLayer(new ActivationTANH(), false, OutPutNeurons));
net.Structure.FinalizeStructure();
net.Reset();
this.modelService = modelService;
pauseSem = new Semaphore(0, 1, "PauseSemaphore");
}
public RoslynBasedModelService(
[NotNull] IModelService modelService,
[NotNull] IRoslynSymbolTranslator roslynSymbolTranslator,
[NotNull] IRelatedSymbolProvider relatedSymbolProvider,
[NotNull] IEqualityComparer <ISymbol> symbolEqualityComparer,
[NotNull] IRoslynWorkspaceProvider roslynWorkspaceProvider)
{
_modelService = modelService;
_roslynSymbolTranslator = roslynSymbolTranslator;
_relatedSymbolProvider = relatedSymbolProvider;
_symbolEqualityComparer = symbolEqualityComparer;
_roslynWorkspaceProvider = roslynWorkspaceProvider;
_asyncLock = new AsyncLock();
}
protected DiagramNodeViewModelBase(IModelService modelService, IDiagramService diagramService,
IFocusTracker <IDiagramShapeUi> focusTracker, IDiagramNode diagramNode)
: base(modelService, diagramService, diagramNode)
{
Name = diagramNode.Name;
Center = diagramNode.Center.ToWpf();
TopLeft = diagramNode.TopLeft.ToWpf();
// Must NOT populate size from model because its value flows from the controls to the models.
FocusTracker = (IWpfFocusTracker <IDiagramShapeUi>)focusTracker;
RelatedNodeCueViewModels = CreateRelatedNodeCueViewModels();
DiagramService.DiagramChanged += OnDiagramChanged;
}
public SelectImageWorkItemAction(IVTubeMonDbConnection vTubeMonDbConnection, IModelService modelService, IFileService fileService)
{
_vTuberSelectionActionParameter = new VTuberSelectionActionParameter(vTubeMonDbConnection.ExecuteDbQueryCommand(new SelectVTubersCommand()));
_browseFileWorkItemActionParameter = new BrowseFileWorkItemActionParameter("Image Files |*.bmp;*.jpg;*.png");
ActionParameters = new ObservableCollection <IDatabaseWorkItemActionParameter>()
{
_vTuberSelectionActionParameter,
_browseFileWorkItemActionParameter
};
_modelService = modelService;
_fileService = fileService;
}
public void CreatePullRequestAllArgsMandatory()
{
var serviceProvider = Substitutes.ServiceProvider;
var gitService = serviceProvider.GetGitService();
var service = new PullRequestService(
Substitute.For <IGitClient>(),
serviceProvider.GetGitService(),
Substitute.For <IVSGitExt>(),
Substitute.For <IApiClientFactory>(),
Substitute.For <IGraphQLClientFactory>(),
serviceProvider.GetOperatingSystem(),
Substitute.For <IUsageTracker>());
IModelService ms = null;
LocalRepositoryModel sourceRepo = null;
LocalRepositoryModel targetRepo = null;
string title = null;
string body = null;
BranchModel source = null;
BranchModel target = null;
Assert.Throws <ArgumentNullException>(() => service.CreatePullRequest(ms, sourceRepo, targetRepo, source, target, title, body));
ms = Substitute.For <IModelService>();
Assert.Throws <ArgumentNullException>(() => service.CreatePullRequest(ms, sourceRepo, targetRepo, source, target, title, body));
sourceRepo = new LocalRepositoryModel {
Name = "name", CloneUrl = "http://github.com/github/stuff", LocalPath = "c:\\path"
};
Assert.Throws <ArgumentNullException>(() => service.CreatePullRequest(ms, sourceRepo, targetRepo, source, target, title, body));
targetRepo = new LocalRepositoryModel {
Name = "name", CloneUrl = "http://github.com/github/stuff", LocalPath = "c:\\path"
};
Assert.Throws <ArgumentNullException>(() => service.CreatePullRequest(ms, sourceRepo, targetRepo, source, target, title, body));
title = "a title";
Assert.Throws <ArgumentNullException>(() => service.CreatePullRequest(ms, sourceRepo, targetRepo, source, target, title, body));
body = "a body";
Assert.Throws <ArgumentNullException>(() => service.CreatePullRequest(ms, sourceRepo, targetRepo, source, target, title, body));
source = new BranchModel("source", sourceRepo);
Assert.Throws <ArgumentNullException>(() => service.CreatePullRequest(ms, sourceRepo, targetRepo, source, target, title, body));
target = new BranchModel("target", targetRepo);
var pr = service.CreatePullRequest(ms, sourceRepo, targetRepo, source, target, title, body);
Assert.NotNull(pr);
}
public CarController(ICarService carService, UserManager <IdentityUser> userManager,
IGenericRepository <Car> genericRepository, IBrandService brandService,
IModelService modelService, IFuelTypeService fuelTypeService, ILocationService locationService, ICarUploadService carUploadService, ITransmisionTypeService transmisionTypeService)
{
_carService = carService;
_userManager = userManager;
_genericRepository = genericRepository;
_brandService = brandService;
_modelService = modelService;
_fuelTypeService = fuelTypeService;
_locationService = locationService;
_carUploadService = carUploadService;
_transmisionTypeService = transmisionTypeService;
}
public WinMain()
{
InitializeComponent();
Icon = Resources.Sound;
audioService = new NAudioService();
modelService = new SqlModelService();
playAudioFileService = new NAudioPlayAudioFileService();
fingerprintCommandBuilder = new FingerprintCommandBuilder();
queryCommandBuilder = new QueryCommandBuilder();
tagService = new BassTagService();
permutationGeneratorService = new PermutationGeneratorService();
spectrumService = new SpectrumService();
imageService = new ImageService();
}
public WinMain()
{
InitializeComponent();
Icon = Resources.Sound;
audioService = new NAudioService();
modelService = new SqlModelService();
playAudioFileService = new NAudioPlayAudioFileService();
fingerprintCommandBuilder = new FingerprintCommandBuilder();
queryCommandBuilder = new QueryCommandBuilder();
tagService = new BassTagService();
permutationGeneratorService = new PermutationGeneratorService();
spectrumService = new SpectrumService();
imageService = new ImageService();
}
public TableEditorViewModel(
IEnumerable <ITreeItemViewModel> rootItems,
IReadOnlyList <IColumnViewModel> columnHeaders,
IModelService <T> modelService,
IItemViewModelFactory <T> itemViewModelFactory,
IRowHeaderContextMenuInfoService rowHeaderContextMenuInfoService = null)
{
this.RootItems = new ObservableCollection <ITreeItemViewModel>(rootItems);
this.ColumnHeaders = (columnHeaders);
this.ModelService = modelService;
this.itemViewModelFactory = itemViewModelFactory;
this.ModelService.CollectionChanged += this.CollectionChanged;
this.rowHeaderContextMenuInfoService = rowHeaderContextMenuInfoService;
}
public IQueryCommand UsingServices(IModelService service, IAudioService audioService, IQueryMatchRegistry registry)
{
modelService = service;
queryMatchRegistry = registry;
if (createFingerprintCommand == null)
{
createFingerprintCommand = () => fingerprintingMethodFromSelector()
.WithFingerprintConfig(queryConfiguration.FingerprintConfiguration)
.UsingServices(audioService);
}
return(this);
}
private ConcurrentDictionary<IModelReference, ResultEntryAccumulator> GetSimilaritiesUsingBatchedStrategy(IEnumerable<HashedFingerprint> queryFingerprints, QueryConfiguration configuration, IModelService modelService)
{
var hashedFingerprints = queryFingerprints as List<HashedFingerprint> ?? queryFingerprints.ToList();
var allCandidates = modelService.ReadSubFingerprints(hashedFingerprints.Select(querySubfingerprint => querySubfingerprint.HashBins), configuration);
var hammingSimilarities = new ConcurrentDictionary<IModelReference, ResultEntryAccumulator>();
foreach (var hashedFingerprint in hashedFingerprints)
{
HashedFingerprint queryFingerprint = hashedFingerprint;
var subFingerprints = allCandidates.Where(candidate => queryMath.IsCandidatePassingThresholdVotes(queryFingerprint, candidate, configuration.ThresholdVotes));
similarityUtility.AccumulateHammingSimilarity(subFingerprints, queryFingerprint, hammingSimilarities);
}
return hammingSimilarities;
}
public OverviewTabViewModel(IEventBus eventBus, IModelService modelService, IHandleService handleService, ISettingsService settingsService, IStartProcessService processService)
{
this.eventBus = eventBus;
this.modelService = modelService;
this.handleService = handleService;
this.settingsService = settingsService;
this.processService = processService;
var playerInformationChanged = new Subscription <PlayerInformationChangedEvent>(OnPlayerInformationChanged);
var skillRecognitionChanged = new Subscription <SkillRecognitionChangedEvent>(OnSkillRecognitionChanged);
var worldInformationChanged = new Subscription <WorldInformationChangedEvent>(OnWorldInformationChanged);
var skillCanBeCasted = new Subscription <SkillCanBeCastedEvent>(OnSkillCanBeCasted);
var hotkeyPressed = new Subscription <HotkeyPressedEvent>(OnHotkeyPressed);
SubscribeBus(playerInformationChanged);
SubscribeBus(skillRecognitionChanged);
SubscribeBus(worldInformationChanged);
SubscribeBus(skillCanBeCasted);
SubscribeBus(hotkeyPressed);
handleService.HandleStatusChanged += OnHandleChanged;
CurrentSkills = new ObservableCollection <string>
{
"pack://application:,,,/Resource/Skill/EmptyFrame.png",
"pack://application:,,,/Resource/Skill/EmptyFrame.png",
"pack://application:,,,/Resource/Skill/EmptyFrame.png",
"pack://application:,,,/Resource/Skill/EmptyFrame.png",
"pack://application:,,,/Resource/Skill/EmptyFrame.png",
"pack://application:,,,/Resource/Skill/EmptyFrame.png",
};
CurrentSkillState = new ObservableCollection <string> {
"Cant cast", "Cant cast", "Cant cast", "Cant cast", "Cant cast", "Cant cast"
};
CurrentActiveState = new ObservableCollection <string> {
"Not active", "Not active", "Not active", "Not active", "Not active", "Not active",
};
CurrentPlayerClass = "pack://application:,,,/Resource/Skill/EmptyFrame.png";
CurrentHealth = 0;
CurrentPrimaryResource = 0;
CurrentPrimaryResource = 0;
var handle = handleService.GetHandle("Diablo III64");
DiabloProcessId = handle != null ? handle.ProcessId : 0;
DiabloClientRectangle = handle != null ? $"{handle.ClientRectangle.Width}x{handle.ClientRectangle.Height}" : "0x0";
SkillIndexSuspensionStatus = new ObservableCollection <bool>(settingsService.SmartFeatureSettings.SkillSuspensionStatus);
}
async Task <IPullRequestModel> GetPullRequestForTip(IModelService modelService, ILocalRepositoryModel repository)
{
if (modelService != null)
{
var pr = await service.GetPullRequestForCurrentBranch(repository);
if (pr != null)
{
return(await modelService.GetPullRequest(pr.Item1, repository.Name, pr.Item2).ToTask());
}
}
return(null);
}
public CarsController(
ICarService carService,
IManufacturerService manufacturerService,
IModelService modelService,
IFuelTypeService fuelTypeService,
ITransmissionTypesService transmissionTypeService,
IDepartmentService departmentService
)
{
this.carService = carService;
this.modelService = modelService;
this.fuelTypeService = fuelTypeService;
this.transmissionTypeService = transmissionTypeService;
}
public bool DownloadFile(string sourceFile, string targetFile, EpisodeGuid creationDate)
{
try
{
IClientProxy <IModelService> clientProxy = GetStreamedProxy();
IModelService proxy = clientProxy.Proxy;
return(PerformDownload(proxy, sourceFile, targetFile, creationDate));
}
catch (Exception ex)
{
throw;
}
}
public BookingController(IBookingService bookingService, IUserService userService, ILocationService locationService, ICarUploadService carUploadService, IBrandService brandService, IFuelTypeService fuelTypeService, ITransmisionTypeService transmisionTypeService, IModelService modelService, IPreBookingService preBookingService, UserManager <IdentityUser> userManager, IGenericRepository <Booking> genericRepository, IEmailService emailService)
{
_bookingService = bookingService;
_userService = userService;
_locationService = locationService;
_carUploadService = carUploadService;
_brandService = brandService;
_fuelTypeService = fuelTypeService;
_transmisionTypeService = transmisionTypeService;
_modelService = modelService;
_preBookingService = preBookingService;
_userManager = userManager;
_genericRepository = genericRepository;
_emailService = emailService;
}
public NodeViewModelService(
IModelService modelService,
IThemeService themeService,
ISelectionService selectionService,
INodeLayoutService nodeLayoutService,
ICodeViewService codeViewService,
Func <Node, Line, DependencyExplorerWindow> dependencyExplorerWindowProvider)
{
this.modelService = modelService;
this.themeService = themeService;
this.selectionService = selectionService;
this.nodeLayoutService = nodeLayoutService;
this.codeViewService = codeViewService;
this.dependencyExplorerWindowProvider = dependencyExplorerWindowProvider;
}
public AdminController(IFuelTypeService fuelTypeService, IColorTypeService colorTypeService,
IBodyTypeService bodyTypeService,
IGearTypeService gearTypeService, IModelService modelService, IUserService userService, ICarService carService, IBrandService brandService, IExtraService extraService, IColorService colorService)
{
this.brandService = brandService;
this.fuelTypeService = fuelTypeService;
this.colorTypeService = colorTypeService;
this.bodyTypeService = bodyTypeService;
this.gearTypeService = gearTypeService;
this.modelService = modelService;
this.userService = userService;
this.carService = carService;
this.extraService = extraService;
this.colorService = colorService;
}
public SettingsViewModel(ThemeService themeService, StringsService stringsService, IModelService modelService)
{
ThemeCollection = new ObservableCollection <TranslationViewModel>(themeService.ResourceNames.Select(r => stringsService.AutoTranslate(r)));
LanguageCollection = new ObservableCollection <string>(stringsService.ResourceNames);
_modelService = modelService;
_themeService = themeService;
_stringsService = stringsService;
_selectedTheme = ThemeCollection.Single(t => t.Key == _themeService.SelectedResource);
_selectedLanguage = stringsService.SelectedResource;
ReadModel();
}
public RelatedNodeCueViewModel(IModelService modelService, IDiagramService diagramService,
IDiagramNode diagramNode, RelatedNodeType relatedNodeType)
: base(modelService, diagramService)
{
_diagramNode = diagramNode;
_directedModelRelationshipType = relatedNodeType.RelationshipType;
_lastModel = modelService.LatestModel;
_lastDiagram = diagramService.LatestDiagram;
ModelService.ModelChanged += OnModelChanged;
DiagramService.DiagramChanged += OnDiagramChanged;
UpdateVisibility();
}
public QueryResult Query(Hashes hashes, QueryConfiguration configuration, IModelService modelService)
{
var groupedQueryResults = GetSimilaritiesUsingBatchedStrategy(hashes, configuration, modelService);
if (!groupedQueryResults.ContainsMatches)
{
return(QueryResult.Empty(hashes));
}
var resultEntries = queryMath.GetBestCandidates(groupedQueryResults, configuration.MaxTracksToReturn, modelService, configuration);
int totalTracksAnalyzed = groupedQueryResults.TracksCount;
int totalSubFingerprintsAnalyzed = groupedQueryResults.SubFingerprintsCount;
return(QueryResult.NonEmptyResult(resultEntries, hashes, totalTracksAnalyzed, totalSubFingerprintsAnalyzed));
}
private object ImportPropertiesOnLocate(DataRequest r, object o)
{
if (o.GetType().IsValueType || o is string || r.Populate)
{
return(o);
}
IModelService modelService = Configuration.Locate <IModelService>();
TypePopulator typePopulator = new TypePopulator(Configuration.Locate <IConstraintHelper>(), new ImportSeleniumTypePropertySelector(Configuration.Locate <IConstraintHelper>()));
typePopulator.Populate(o, r, modelService.GetModel(r.RequestedType));
return(0);
}
public VisualizationService(
[NotNull] IModelService modelService,
[NotNull] Func <IModel, IDiagramService> diagramServiceFactory,
[NotNull] Func <IDiagramService, IUiService> uiServiceFactory,
[NotNull] IEnumerable <Func <IDiagramService, IDiagramPlugin> > diagramPluginFactories)
{
_modelService = modelService;
_diagramServiceFactory = diagramServiceFactory;
_uiServiceFactory = uiServiceFactory;
_diagramPluginFactories = diagramPluginFactories;
_diagramServices = new Dictionary <DiagramId, IDiagramService>();
_diagramUis = new Dictionary <DiagramId, IUiService>();
_diagramPlugins = new Dictionary <DiagramId, List <IDiagramPlugin> >();
}
public void SetUp()
{
modelService = new InMemoryModelService();
tagService.Setup(service => service.GetTagInfo(It.IsAny <string>()))
.Returns(new TagInfo
{
Artist = "Chopin",
Album = string.Empty,
Title = "Nocturne C#",
ISRC = "USUR19980187",
Year = 1997,
Duration = 193.07d
});
}
public RoslynDiagramViewModel(
IModelService modelService,
IDiagramService diagramService,
bool initialIsDescriptionVisible,
double minZoom,
double maxZoom,
double initialZoom)
: base(
modelService,
diagramService,
new RoslynDiagramShapeUiFactory(initialIsDescriptionVisible),
minZoom,
maxZoom,
initialZoom)
{
}
public AgentController(IModelService <Agent, AgentDto> modelService,
IEntityService <UserAccount> userAccountService,
IEntityService <Agent> agentService,
IFastHasher fastHasher,
IUserProvider userProvider,
IPasswordService passwordService,
IPathProvider pathProvider) : base(modelService)
{
_userAccountService = userAccountService;
_agentService = agentService;
_fastHasher = fastHasher;
_userProvider = userProvider;
_passwordService = passwordService;
_pathProvider = pathProvider;
modelService.SetBaseFilter(filter => filter.Where(a => a.RealEstateId == _userProvider.RealEstateId && !a.Deleted && a.UserAccount.IsActive != false));
}
public IObservable <IPullRequestModel> CreatePullRequest(IModelService modelService,
ILocalRepositoryModel sourceRepository, IRepositoryModel targetRepository,
IBranch sourceBranch, IBranch targetBranch,
string title, string body
)
{
Extensions.Guard.ArgumentNotNull(modelService, nameof(modelService));
Extensions.Guard.ArgumentNotNull(sourceRepository, nameof(sourceRepository));
Extensions.Guard.ArgumentNotNull(targetRepository, nameof(targetRepository));
Extensions.Guard.ArgumentNotNull(sourceBranch, nameof(sourceBranch));
Extensions.Guard.ArgumentNotNull(targetBranch, nameof(targetBranch));
Extensions.Guard.ArgumentNotNull(title, nameof(title));
Extensions.Guard.ArgumentNotNull(body, nameof(body));
return(PushAndCreatePR(modelService, sourceRepository, targetRepository, sourceBranch, targetBranch, title, body).ToObservable());
}
public CreateEditActionWizard()
{
InitializeComponent();
applicationService = MetaManagerServices.GetApplicationService();
dialogService = MetaManagerServices.GetDialogService();
modelService = MetaManagerServices.GetModelService();
storedProcedureControl.ChangedSP += new EventHandler(NewSpSelected);
targetProcedureBtn.Checked = true;
targetProcedureBtn_Click(this, null);
}
public PaymentsVM(IModelService modelService)
: base(modelService)
{
Title = "Plaćanja";
_payments = new ReadOnlyObservableCollection <PaymentVM>(_paymentsInternal);
//_collectionView = CollectionViewSource.GetDefaultView(_payments);
//_collectionView.Filter = delegate(object obj)
//{
// return FilterPayment(obj);
//};
// if (IsInDesignMode) LoadModel();
}
public RequestController(IModelService <Request, RequestDto> modelService, IFastHasher hasher,
IUserProvider userProvider, IEntityService <RequestState> requestStateService, IEntityService <RequestAgent> requestAgentService,
IEntityService <Property> propertyService, IEntityService <Workflow> workflowService, IEntityService <WorkflowStep> workflowStepService,
IUpdateSignaler signaler, IEntityService <UserAccount> userAccountService)
: base(modelService)
{
_hasher = hasher;
_userProvider = userProvider;
_requestStateService = requestStateService;
_requestAgentService = requestAgentService;
_propertyService = propertyService;
_workflowService = workflowService;
_workflowStepService = workflowStepService;
_signaler = signaler;
_userAccountService = userAccountService;
}
static RepositoryCloneViewModel GetVM(IModelService modelService, IRepositoryCloneService cloneService, IOperatingSystem os)
{
var connection = Substitute.For <IConnection>();
connection.HostAddress.Returns(HostAddress.GitHubDotComHostAddress);
var modelServiceFactory = Substitute.For <IModelServiceFactory>();
modelServiceFactory.CreateAsync(connection).Returns(modelService);
var vm = new RepositoryCloneViewModel(
modelServiceFactory,
cloneService,
os);
vm.InitializeAsync(connection).Wait();
return(vm);
}
public RepositoryHost(
IApiClient apiClient,
IModelService modelService,
ILoginCache loginCache,
ITwoFactorChallengeHandler twoFactorChallengeHandler)
{
ApiClient = apiClient;
ModelService = modelService;
this.loginCache = loginCache;
this.twoFactorChallengeHandler = twoFactorChallengeHandler;
Debug.Assert(apiClient.HostAddress != null, "HostAddress of an api client shouldn't be null");
Address = apiClient.HostAddress;
hostAddress = apiClient.HostAddress;
isEnterprise = !hostAddress.IsGitHubDotCom();
Title = apiClient.HostAddress.Title;
}
public RepositoryHost(
IApiClient apiClient,
IModelService modelService,
ILoginCache loginCache,
ITwoFactorChallengeHandler twoFactorChallengeHandler)
{
ApiClient = apiClient;
ModelService = modelService;
this.loginCache = loginCache;
this.twoFactorChallengeHandler = twoFactorChallengeHandler;
Debug.Assert(apiClient.HostAddress != null, "HostAddress of an api client shouldn't be null");
Address = apiClient.HostAddress;
hostAddress = apiClient.HostAddress;
isEnterprise = !hostAddress.IsGitHubDotCom();
Title = apiClient.HostAddress.Title;
}
public DiagramNodeViewModel(
[NotNull] IModelService modelService,
[NotNull] IDiagramService diagramService,
[NotNull] IRelatedNodeTypeProvider relatedNodeTypeProvider,
[NotNull] IFocusTracker <IDiagramShapeUi> focusTracker,
[NotNull] IDiagramNode diagramNode)
: base(modelService, diagramService, diagramNode)
{
PopulateFromDiagramNode(diagramNode);
// Must NOT populate size from model because its value flows from the controls to the models.
RelatedNodeTypeProvider = relatedNodeTypeProvider;
FocusTracker = (IWpfFocusTracker <IDiagramShapeUi>)focusTracker;
RelatedNodeCueViewModels = CreateRelatedNodeCueViewModels();
DiagramService.DiagramChanged += OnDiagramChanged;
}
public TestRunner(
string[] scenarious,
IModelService modelService,
IAudioService audioService,
ITagService tagService,
IFingerprintCommandBuilder fcb,
IQueryCommandBuilder qcb,
string pathToResultsFolder)
: this(DependencyResolver.Current.Get<ITestRunnerUtils>())
{
this.scenarious = scenarious;
this.modelService = modelService;
this.audioService = audioService;
this.tagService = tagService;
this.fcb = fcb;
this.qcb = qcb;
this.pathToResultsFolder = pathToResultsFolder;
}
public ResultEntry Validate(
ResultEntry result,
IStride validationStride,
string pathToAudioFile,
IModelService modelService,
IAudioService audioService)
{
double startAt = result.TrackStartsAt, length = result.QueryLength - result.TrackStartsAt;
if (startAt + result.Track.Length < result.QueryLength)
{
length = result.Track.Length;
}
var newResult = queryCommandBuilder.BuildQueryCommand()
.From(pathToAudioFile, length, startAt)
.WithFingerprintConfig(config => config.Stride = validationStride)
.UsingServices(modelService, audioService)
.Query()
.Result;
if (!newResult.ContainsMatches)
{
return result;
}
var newEntry = newResult.BestMatch;
if (newEntry.Confidence > result.Confidence)
{
return new ResultEntry(
newEntry.Track,
newEntry.QueryMatchStartsAt,
newEntry.QueryMatchLength,
newEntry.TrackMatchStartsAt,
newEntry.TrackStartsAt + result.TrackStartsAt,
newEntry.Confidence,
newEntry.HammingSimilaritySum,
newEntry.QueryLength,
newEntry.BestMatch);
}
return result;
}
public WinQueryResults(
int secondsToAnalyze,
int startSecond,
int hashTables,
int hashKeys,
int threshold,
IStride queryStride,
ITagService tagService,
IModelService modelService,
IAudioService audioService,
IQueryCommandBuilder queryCommandBuilder)
{
InitializeComponent();
Icon = Resources.Sound;
this.secondsToAnalyze = secondsToAnalyze;
this.startSecond = startSecond;
this.queryStride = queryStride;
this.hashTables = hashTables;
this.hashKeys = hashKeys;
this.threshold = threshold;
this.tagService = tagService;
this.modelService = modelService;
this.audioService = audioService;
this.queryCommandBuilder = queryCommandBuilder;
// ReSharper disable PossibleNullReferenceException
_dgvResults.Columns.Add(ColSongName, "Initial Song");
_dgvResults.Columns[ColSongName].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColResultName, "Result Song");
_dgvResults.Columns[ColResultName].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColResult, "ISRC Match");
_dgvResults.Columns[ColResult].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColHammingAvg, "Hamming Distance");
_dgvResults.Columns[ColHammingAvg].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColNumberOfCandidates, "Number of candidates");
_dgvResults.Columns[ColNumberOfCandidates].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColISRC, "Result ISRC");
_dgvResults.Columns[ColISRC].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
// ReSharper restore PossibleNullReferenceException
_btnExport.Enabled = false;
}
public QueryResult Query(List<HashedFingerprint> queryFingerprints, QueryConfiguration configuration, IModelService modelService)
{
ConcurrentDictionary<IModelReference, ResultEntryAccumulator> hammingSimilarities;
if (modelService.SupportsBatchedSubFingerprintQuery)
{
hammingSimilarities = GetSimilaritiesUsingBatchedStrategy(queryFingerprints, configuration, modelService);
}
else
{
hammingSimilarities = GetSimilaritiesUsingNonBatchedStrategy(queryFingerprints, configuration, modelService);
}
if (!hammingSimilarities.Any())
{
return QueryResult.EmptyResult();
}
var resultEntries = queryMath.GetBestCandidates(queryFingerprints, hammingSimilarities, configuration.MaxTracksToReturn, modelService, configuration.FingerprintConfiguration);
return QueryResult.NonEmptyResult(resultEntries);
}
public QueryResult Query(IModelService modelService, IEnumerable<HashData> hashes, IQueryConfiguration queryConfiguration)
{
var hammingSimilarities = new Dictionary<IModelReference, int>();
foreach (var hash in hashes)
{
var subFingerprints = GetSubFingerprints(modelService, hash, queryConfiguration);
foreach (var subFingerprint in subFingerprints)
{
int similarity = SimilarityUtility.CalculateHammingSimilarity(hash.SubFingerprint, subFingerprint.Signature);
if (hammingSimilarities.ContainsKey(subFingerprint.TrackReference))
{
hammingSimilarities[subFingerprint.TrackReference] += similarity;
}
else
{
hammingSimilarities.Add(subFingerprint.TrackReference, similarity);
}
}
}
if (hammingSimilarities.Any())
{
var topMatches = hammingSimilarities.OrderByDescending(pair => pair.Value).Take(queryConfiguration.MaximumNumberOfTracksToReturnAsResult);
var resultSet = topMatches.Select(match => new ResultEntry { Track = modelService.ReadTrackByReference(match.Key), Similarity = match.Value }).ToList();
return new QueryResult
{
ResultEntries = resultSet,
IsSuccessful = true,
AnalyzedCandidatesCount = hammingSimilarities.Count
};
}
return new QueryResult
{
ResultEntries = Enumerable.Empty<ResultEntry>().ToList(),
IsSuccessful = false,
AnalyzedCandidatesCount = 0
};
}
public WinDbFiller(
IFingerprintCommandBuilder fingerprintCommandBuilder,
IAudioService audioService,
ITagService tagService,
IModelService modelService)
{
this.modelService = modelService;
this.fingerprintCommandBuilder = fingerprintCommandBuilder;
this.audioService = audioService;
this.tagService = tagService;
InitializeComponent();
Icon = Resources.Sound;
foreach (object item in ConfigurationManager.ConnectionStrings)
{
_cmbDBFillerConnectionString.Items.Add(item.ToString());
}
if (_cmbDBFillerConnectionString.Items.Count > 0)
{
_cmbDBFillerConnectionString.SelectedIndex = 0;
}
_btnStart.Enabled = false;
_btnStop.Enabled = false;
_nudThreads.Value = MaxThreadToProcessFiles;
_pbTotalSongs.Visible = false;
hashAlgorithm = 0;
_lbAlgorithm.SelectedIndex = 0; /*Set default algorithm LSH*/
if (hashAlgorithm == HashAlgorithm.LSH)
{
_nudHashKeys.ReadOnly = false;
_nudHashTables.ReadOnly = false;
}
string[] items = Enum.GetNames(typeof(StrideType)); /*Add enumeration types in the combo box*/
_cmbStrideType.Items.AddRange(items);
_cmbStrideType.SelectedIndex = 0;
fileList = new List<string>();
}
public QueryResult Query(IModelService modelService, IEnumerable<HashedFingerprint> hashedFingerprints, QueryConfiguration queryConfiguration)
{
var hammingSimilarities = new Dictionary<IModelReference, int>();
foreach (var hashedFingerprint in hashedFingerprints)
{
var subFingerprints = GetSubFingerprints(modelService, hashedFingerprint, queryConfiguration);
foreach (var subFingerprint in subFingerprints)
{
int hammingSimilarity = similarityCalculationUtility.CalculateHammingSimilarity(hashedFingerprint.SubFingerprint, subFingerprint.Signature);
if (!hammingSimilarities.ContainsKey(subFingerprint.TrackReference))
{
hammingSimilarities.Add(subFingerprint.TrackReference, 0);
}
hammingSimilarities[subFingerprint.TrackReference] += hammingSimilarity;
}
}
if (!hammingSimilarities.Any())
{
return NoResult;
}
var resultEntries = hammingSimilarities.OrderByDescending(e => e.Value)
.Take(queryConfiguration.MaximumNumberOfTracksToReturnAsResult)
.Select(e => new ResultEntry
{
Track = modelService.ReadTrackByReference(e.Key),
Similarity = e.Value
})
.ToList();
return new QueryResult
{
ResultEntries = resultEntries,
IsSuccessful = true,
AnalyzedCandidatesCount = hammingSimilarities.Count
};
}
public QueryResults(
int secondsToAnalyze,
int startSecond,
int hashTables,
int hashKeys,
int threshold,
IStride queryStride,
ITagService tagService,
IModelService modelService,
IAudioService audioService,
IQueryCommandBuilder queryCommandBuilder)
{
this.secondsToAnalyze = secondsToAnalyze;
this.startSecond = startSecond;
this.queryStride = queryStride;
this.hashTables = hashTables;
this.hashKeys = hashKeys;
this.threshold = threshold;
this.tagService = tagService;
this.modelService = modelService;
this.audioService = audioService;
this.queryCommandBuilder = queryCommandBuilder;
}
public WinCheckHashBins(IFingerprintQueryBuilder queryBuilder, ITagService tagService, IModelService modelService, IExtendedAudioService audioService)
{
this.queryBuilder = queryBuilder;
this.tagService = tagService;
this.modelService = modelService;
this.audioService = audioService;
InitializeComponent();
Icon = Resources.Sound;
AddConnectionStringsToComboBox();
_cmbAlgorithm.SelectedIndex = (int)hashAlgorithm;
string[] items = Enum.GetNames(typeof(StrideType));
_cmbStrideType.Items.AddRange(items.ToArray<object>());
_cmbStrideType.SelectedIndex = 3;
switch (_cmbAlgorithm.SelectedIndex)
{
case (int)HashAlgorithm.LSH:
_gbMinHash.Enabled = true;
_gbNeuralHasher.Enabled = false;
break;
case (int)HashAlgorithm.NeuralHasher:
_gbMinHash.Enabled = false;
_gbNeuralHasher.Enabled = true;
break;
case (int)HashAlgorithm.None:
_gbMinHash.Enabled = false;
_gbNeuralHasher.Enabled = false;
break;
}
_gbQueryMicrophoneBox.Enabled = audioService.IsRecordingSupported;
}
void InitializationEnvironment()
{
_modelService = InjectionRepository.Instance.Get<IModelService>();
_backdropImage = Resources.Load("Image/LevelBackground/0") as Texture2D;
var layoutContract = _modelService.GetProperLayout(Screen.width, Screen.height, 100);
var sliceContract = _modelService.GetSlice(_backdropImage, layoutContract, SlicePattern.Default);
var pieceContracts = _modelService.GeneratePieceContracts(sliceContract);
_rows = layoutContract.Rows;
_columns = layoutContract.Columns;
_visionWidth = GlobalConfiguration.PictureHeightInMeter * Screen.width / Screen.height;
_pieceWidth = _visionWidth / _columns;
_flightHeight = _pieceWidth;
_circleDistance = Mathf.PI * _flightHeight / 2;
_backdropPieceViewModels = new BackdropPieceViewModel[layoutContract.Rows, layoutContract.Columns];
_backdropNormalMap = _modelService.GenerateNormalMap(sliceContract);
_straightSpeed = GlobalConfiguration.PictureHeightInMeter;
_corneringSpeed = _straightSpeed * 0.2f;
_rotationSpeed = 45 / _pieceWidth;
for (var i = 0; i < _rows; i++)
{
for (var j = 0; j < _columns; j++)
{
var pieceContract = pieceContracts[i, j];
_backdropPieceViewModels[i, j] = new BackdropPieceViewModel
{
Position = pieceContract.Position,
MappingMesh = pieceContract.MappingMesh,
BackseatMesh = pieceContract.BackseatMesh,
Distance = _circleDistance + 4f * (_visionWidth - 2 * (pieceContract.Position.x + _pieceWidth * (UnityEngine.Random.value - 1)))
};
}
}
}
public WinQueryResults(
int secondsToAnalyze,
int startSecond,
int hashTables,
int hashKeys,
int threshold,
IStride queryStride,
ITagService tagService,
IModelService modelService,
IFingerprintQueryBuilder fingerprintQueryBuilder)
{
InitializeComponent();
Icon = Resources.Sound;
this.secondsToAnalyze = secondsToAnalyze;
this.startSecond = startSecond;
this.queryStride = queryStride;
this.hashTables = hashTables;
this.hashKeys = hashKeys;
this.threshold = threshold;
this.tagService = tagService;
this.modelService = modelService;
this.fingerprintQueryBuilder = fingerprintQueryBuilder;
// ReSharper disable PossibleNullReferenceException
_dgvResults.Columns.Add(ColSongName, "Initial Song");
_dgvResults.Columns[ColSongName].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColResultName, "Result Song");
_dgvResults.Columns[ColResultName].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColResult, "Result");
_dgvResults.Columns[ColResult].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColHammingAvg, "Hamming Distance");
_dgvResults.Columns[ColHammingAvg].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
_dgvResults.Columns.Add(ColElapsedTime, "Elapsed Time");
_dgvResults.Columns[ColElapsedTime].AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
// ReSharper restore PossibleNullReferenceException
_btnExport.Enabled = false;
}
public ModelController(IModelService modelService)
{
_modelService = modelService;
}
public App(IModelService modelService)
{
this.modelService = modelService;
ConfigureRoutes();
}
public WinNetworkTrainer(IModelService modelService)
{
this.modelService = modelService;
InitializeComponent();
Icon = Resources.Sound;
_cmbActivationFunction.DataSource = new List<object>(dataProvider);
_cmbActivationFunction.SelectedIndex = 0;
_cmbActivationFunctionHidden.DataSource = new List<object>(dataProvider);
_cmbActivationFunctionHidden.SelectedIndex = 0;
_cmbActivationFunctionOutput.DataSource = new List<object>(dataProvider);
_cmbActivationFunctionOutput.SelectedIndex = 0;
}
