/// <summary>
/// (search.merge)
/// </summary>
/// <param name="query"></param>
/// <returns>catalogs contains song, album, artist</returns>
public async override Task <CatalogContent> GetCatalogAsync(string query, int pageNumber = 1, int?pageSize = default(int?))
{
return(await this.GetResponse(new CatalogContent(), SearchMethod.Merge(query, pageNumber, pageSize), (o) =>
{
ContentConverter.Convert(o, (merge)JsonConvert.DeserializeObject(o.Value, typeof(merge)));
}));
}
private Type GetRawSearchTypeForSearchMethod(SearchMethod searchMethod)
{
switch (searchMethod)
{
case SearchMethod.TrialAndError:
return(typeof(TrialAndError <>));
case SearchMethod.HillClimbing:
return(typeof(HillClimbing <>));
case SearchMethod.BreadthFirstSearch:
return(typeof(BreadthFirstSearch <>));
case SearchMethod.DepthFirstSearch:
return(typeof(DepthFirstSearch <>));
case SearchMethod.BackTrack:
return(typeof(BackTrack <>));
case SearchMethod.OptimalSearch:
return(typeof(OptimalSearch <>));
case SearchMethod.AStar:
return(typeof(AStar <>));
}
return(null);
}
/// <summary>
/// 支持对IQueryable通过字符串指定属性的查询
/// </summary>
/// <typeparam name = "TEntity"></typeparam>
/// <param name = "table">IQueryable的查询对象</param>
/// <param name = "field">属性名</param>
/// <param name = "method">判断谓词</param>
/// <param name = "value">值</param>
/// <returns></returns>
public static IQueryable <TEntity> Where <TEntity>(this IQueryable <TEntity> table, string field,
SearchMethod method, object value)
{
return(table.Where(new SearchItem {
Field = field, Method = method, Value = value
}));
}
public IList <Benday.EasyAuthDemo.Api.DomainModels.Person> Search(
SearchMethod searchTypeFirstName = SearchMethod.Contains,
string searchValueFirstName = null,
SearchMethod searchTypeLastName = SearchMethod.Contains,
string searchValueLastName = null,
SearchMethod searchTypePhoneNumber = SearchMethod.Contains,
string searchValuePhoneNumber = null,
SearchMethod searchTypeEmailAddress = SearchMethod.Contains,
string searchValueEmailAddress = null,
SearchMethod searchTypeStatus = SearchMethod.Contains,
string searchValueStatus = null,
SearchMethod searchTypeCreatedBy = SearchMethod.Contains,
string searchValueCreatedBy = null,
SearchMethod searchTypeLastModifiedBy = SearchMethod.Contains,
string searchValueLastModifiedBy = null,
SearchMethod searchTypeThingy = SearchMethod.Contains,
string searchValueThingy = null,
string sortBy = null, string sortByDirection = null,
int maxNumberOfResults = 100)
{
WasSearchUsingParametersCalled = true;
return(SearchUsingParametersReturnValue);
}
public void ManualSolve(int card1, int card2, int card3, int card4)
{
solver = new DFS();
solver.acceptInput(new Cards(card1 + "", card2 + "", card3 + "", card4 + ""));
solver.search();
PrintOutput(solver.receiveOutput());
}
private IEnumerable <SearchDataDto> GetUser(SearchMethod methodResult, string searchTerm)
{
var dataQuery = this.usersRepository.AllAsNoTracking().AsQueryable();
if (methodResult == SearchMethod.Id)
{
dataQuery = dataQuery
.Where(a => a.Id == searchTerm)
.AsQueryable();
}
else if (methodResult == SearchMethod.Username || methodResult == SearchMethod.Title)
{
dataQuery = dataQuery
.Where(a => a.UserName == searchTerm)
.AsQueryable();
}
return(dataQuery
.Select(d => new SearchDataDto
{
Id = d.Id,
Title = d.Email,
Content = $"{d.FirstName} {d.LastName}",
Username = d.UserName,
})
.ToList());
}
private IEnumerable <SearchDataDto> GetReview(SearchMethod methodResult, string searchTerm)
{
var dataQuery = this.customersReviesRepository.AllAsNoTracking().AsQueryable();
if (methodResult == SearchMethod.Id)
{
if (int.TryParse(searchTerm, out int id))
{
dataQuery = dataQuery
.Where(a => a.Id == id)
.AsQueryable();
}
else
{
return(null);
}
}
else if (methodResult == SearchMethod.Username || methodResult == SearchMethod.Title)
{
dataQuery = dataQuery
.Where(a => a.User.UserName == searchTerm)
.AsQueryable();
}
return(dataQuery
.Select(d => new SearchDataDto
{
Id = d.Id.ToString(),
Title = d.Appraiser.UserName,
Content = d.Comment,
Username = d.User.UserName,
})
.ToList());
}
private void Check(SearchMethod Mode = SearchMethod.Static)
{
if (LP != DaCamera.transform.position || LR != DaCamera.transform.rotation)
{
LP = DaCamera.transform.position; LR = DaCamera.transform.rotation;
if (Mode == SearchMethod.Normal)
{
Populate(ControlTag);
}
VisibleObjects = 0;
foreach (GameObject GO in SFCO)
{
Plane[] planes = GeometryUtility.CalculateFrustumPlanes(DaCamera);
OS = GeometryUtility.TestPlanesAABB(planes, GO.GetComponent <Renderer>().bounds);
VisibleObjects += OS ? 1 : 0;
if (GO.GetComponent <Renderer>().enabled != OS)
{
GO.GetComponent <Renderer>().enabled = OS;
}
}
}
}
/// <summary>
/// (search.catalogSug)
/// </summary>
/// <param name="query"></param>
/// <returns>suggestion contain song, album, artist</returns>
public async override Task <CatalogSuggestionContent> GetCatalogSuggestionAsync(string query)
{
return(await this.GetResponse(new CatalogSuggestionContent(), SearchMethod.CatalogSug(query), (o) =>
{
catalogSug catalogSug = (catalogSug)JsonConvert.DeserializeObject(o.Value, typeof(catalogSug));
}));
}
private static ISearch GetSearch <T>(SearchMethod searchMethod, Problem <T> problem) where T : class, IState
{
switch (searchMethod)
{
case SearchMethod.BreadthFirstSearch:
return(new BreadthFirstSearch <T>(problem));
case SearchMethod.DepthFirstSearch:
return(new DepthFirstSearch <T>(problem));
case SearchMethod.BackTrack:
return(new BackTrack <T>(problem));
case SearchMethod.OptimalSearch:
return(new OptimalSearch <T>(problem));
case SearchMethod.AStar:
return(new AStar <T>(problem));
case SearchMethod.TrialAndError:
return(new TrialAndError <T>(problem));
case SearchMethod.HillClimbing:
return(new HillClimbing <T>(problem));
}
return(null);
}
async Task <SearchResponse <T> > RunSearch <T>(HttpClient httpClient, SearchMethod method, string url, IDictionary <string, string> parameters)
{
var info = new SearchInfo(url, parameters);
var request = method == SearchMethod.Post ?
httpClient.PostAsync(url, new FormUrlEncodedContent(parameters)) :
httpClient.GetAsync(MakeGetUrl(url, parameters));
using (var httpResponse = await request.ConfigureAwait(false))
{
using (var content = await httpResponse.Content.ReadAsStreamAsync().ConfigureAwait(false))
using (var streamReader = new StreamReader(content, Encoding.UTF8))
using (var jsonReader = new JsonTextReader(streamReader))
{
if (!httpResponse.IsSuccessStatusCode)
{
throw HandleSearchError(httpResponse, jsonReader, info);
}
var response = _responseDeserializer.Deserialize <SearchResponse <T> >(jsonReader);
response.Request = info;
return(response);
}
}
}
// Popis: Pomocí zvolené vyhledávací metody se pokusí najít blok obsahující interval hodnot,
// do které spadá hledaná hodnota. Při prohledávání bloků načítá pouze jejich hlavičky.
// Ve chvíli, kdy najde správný blokc, celý ho načt a uloží do paměti. Nad jeho daty
// následně provádí opěd zvolenou metodu vyhledávání dat, tentokrát již na poli hodnot.
/// <summary>
/// Find item in binary data
/// </summary>
/// <param name="key">Searching key</param>
/// <param name="method">Searching method</param>
/// <returns>Found key or null</returns>
public T Find(string key, SearchMethod method = SearchMethod.Interpolation)
{
// Get searched hash
int keyHash = GetHash(key);
FileStream file = GetFileStream(FileMode.Open);
FileMeta metadata;
int headerLength;
{
// Read file meta block
(int offset, FileMeta data)header = ReadMetaHeader(file);
metadata = header.data;
headerLength = header.offset;
}
// Find block data with valid range
DataItem[] values = FindBlockData(file, metadata, keyHash, headerLength, method).blockData;
T value = default;
if (values != null && values.Length > 0)
{
// Find value in block data
value = SearchInBlock(values, keyHash, key, method);
}
file.Close();
return(value);
}
public List <ZhedStep> Solve(SearchMethod searchMethod)
{
Func <ZhedBoard, int> heuristic = Heuristic5;
PriorityQueue <Node> queue = new PriorityQueue <Node>();
queue.Enqueue(new Node(this.board, null, null, 1), 1);
DFSPriority = int.MaxValue;
int visitedNodes = 0;
while (queue.Count > 0)
{
visitedNodes++;
Node nextNode = queue.Dequeue();
// Console.WriteLine("Visit number {0}", visitedNodes); nextNode.board.PrintBoard();
// Console.WriteLine("Value of board: {0}" , nextNode.board.getBoardMaxValue());
if (nextNode.board.isOver)
{
Console.WriteLine("Visited {0} nodes", visitedNodes);
return(GetPath(nextNode));
}
List <Node> children = GetNextGeneration(nextNode, heuristic);
foreach (Node node in children)
{
queue.Enqueue(node, NodePriority(searchMethod, node));
}
}
return(null);
}
public DossierSearchBoxPopup(SearchField searchField)
{
InitializeComponent();
this.ArchiveField = searchField.Field;
comboBoxExtendedAndOr.Visible = searchField.Relation != SearchField.Relations.None;
comboBoxExtendedAndOr.Location = new Point(lblField.Location.X + lblField.Width + 5, comboBoxExtendedAndOr.Location.Y);
this.Width = comboBoxExtendedAndOr.Location.X + comboBoxExtendedAndOr.Width + 50;
if (comboBoxExtendedAndOr.Visible == false)
{
this.Width -= comboBoxExtendedAndOr.Width;
}
contextMenuStripSelect.Enabled = false;
searchMethodBindingSource.DataSource = SearchMethod.GetAllSearchMethods();
switch (searchField.Relation)
{
case SearchField.Relations.None:
break;
case SearchField.Relations.And:
comboBoxExtendedAndOr.SelectedIndex = 0;
break;
case SearchField.Relations.Or:
comboBoxExtendedAndOr.SelectedIndex = 1;
break;
}
comboBoxExtendedMethod.SelectedValue = searchField.Method.Code;
textBoxExtendedValue.Text = searchField.Value;
btnAdd.Text = "ثبت";
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value is SearchMethod)
{
SearchMethod searchMethod = (SearchMethod)value;
switch (searchMethod)
{
case SearchMethod.HillClimbing:
return("Hegymászó módszer");
case SearchMethod.TrialAndError:
return("Próba-hiba módszer");
case SearchMethod.BackTrack:
return("BackTrack");
case SearchMethod.BreadthFirstSearch:
return("Szélességi kereső");
case SearchMethod.DepthFirstSearch:
return("Mélységi kereső");
case SearchMethod.OptimalSearch:
return("Optimális kereső");
case SearchMethod.AStar:
return("A* kereső");
}
}
return(value);
}
/// <summary>
/// (search.common)
/// </summary>
/// <param name="query"></param>
/// <returns>only songs</returns>
public async override Task <SongContent> GetSongsAsync(string query, int pageNumber = 1, int?pageSize = default(int?))
{
return(await this.GetResponse(new SongContent(), SearchMethod.Common(query, pageNumber, pageSize), (o) =>
{
common common = (common)JsonConvert.DeserializeObject(o.Value, typeof(common));
}));
}
public async Task <IActionResult> List(string name, [FromQuery] SearchMethod method = SearchMethod.Simple, [FromQuery] string query = null, [FromQuery] bool desc = true, [FromQuery] string skipToken = null, [FromQuery] int limit = 20, [FromQuery] RenderStyle style = RenderStyle.Default)
{
var collection = await _settings.FindCollectionAsync(name);
var items = method == SearchMethod.Simple
? await _data.SearchAsync(name, query, skipToken, limit, desc)
: await _data.QueryAsync(name, query, skipToken, limit, desc);
if (!desc)
{
items = items.Reverse();
}
var model = new CollectionViewModel
{
SearchMethod = method,
SeachQuery = query,
TitlePath = collection.TitlePath,
Items = items,
CollectionName = name,
DisplayName = collection.DisplayName,
Procedures = collection.Procedures ?? new ProcedureInfo[0],
Limit = limit
};
if (style == RenderStyle.NoBlade)
{
return(View("ListNoBlade", model));
}
return(View(model));
}
//This is horribly inefficient. Should only be used when absolutely necessary, like finding a troll
public IEnumerable<ContentObject> DeepSearch(IEnumerable<string> terms, SearchMethod method = SearchMethod.OR)
{
IEnumerable<ContentObject> results = null;
foreach (string term in terms)
results = combineResults(results, DeepSearch(term), method);
return results;
}
public ISearch CreateSearch(SearchMethod searchMethod)
{
Type rawSearchType = GetRawSearchTypeForSearchMethod(searchMethod);
Type searchType = rawSearchType.MakeGenericType(this.stateType);
ISearch searchInstance = Activator.CreateInstance(searchType, problem) as ISearch;
return(searchInstance);
}
public void AddArgument(
string propertyName,
SearchMethod method,
string value,
SearchOperator combineWithOtherArgumentsAs = SearchOperator.And)
{
Arguments.Add(
new SearchArgument(propertyName, method, value, combineWithOtherArgumentsAs));
}
private void comboBoxExtendedMethod_SelectedValueChanged(object sender, EventArgs e)
{
Njit.Program.Controls.ComboBoxExtended c = sender as Njit.Program.Controls.ComboBoxExtended;
if (c.SelectedItem != null)
{
SearchMethod method = c.SelectedItem as SearchMethod;
textBoxExtendedValue_Advance.Enabled = textBoxExtendedValue_Simple.Enabled = method.RequiredValue;
}
}
private static List <SearchField> LoadSearchFields(Model.Archive.ArchiveDataClassesDataContext dc, Model.Archive.ReportDetail reportDetail, List <SearchField> searchFields)
{
foreach (var item in dc.ReportDetails.Where(t => t.ParentID == reportDetail.ID))
{
List <SearchField> innerSearchFields = new List <SearchField>();
LoadSearchFields(dc, item, innerSearchFields);
searchFields.Add(new SearchField(item.ArchiveField, SearchMethod.GetAllSearchMethods().Where(t => t.Code == item.MethodCode).Single(), item.Value, (SearchField.Relations)item.RelationCode, innerSearchFields));
}
return(searchFields);
}
public SearchArgument(
string propertyName,
SearchMethod method,
string searchValue,
SearchOperator addAsOperator = SearchOperator.And)
{
PropertyName = propertyName ?? throw new ArgumentNullException(nameof(propertyName));
Method = method;
SearchValue = searchValue ?? throw new ArgumentNullException(nameof(searchValue));
Operator = addAsOperator;
}
protected async void Search(object source, ElapsedEventArgs e)
{
isSearching = true;
isShowingSuggestions = false;
await InvokeAsync(StateHasChanged);
Suggestions = (await SearchMethod.Invoke(searchText)).ToArray();
isSearching = false;
isShowingSuggestions = true;
await InvokeAsync(StateHasChanged);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (this.DesignMode)
{
return;
}
this.archiveTabBindingSource.DataSource = Controller.Archive.ArchiveTabController.GetActiveDossierTabs();
searchMethodBindingSource.DataSource = SearchMethod.GetAllSearchMethods();
this.tabControl1.SelectedTab = tabPage3;
}
//This is horribly inefficient. Should only be used when absolutely necessary, like finding a troll
public IEnumerable <ContentObject> DeepSearch(IEnumerable <string> terms, SearchMethod method = SearchMethod.OR)
{
IEnumerable <ContentObject> results = null;
foreach (string term in terms)
{
results = combineResults(results, DeepSearch(term), method);
}
return(results);
}
/// <summary>
/// Найти элемент
/// </summary>
/// <param name="webElement">Веб-элемент</param>
/// <param name="searchMethod">Метод поиска</param>
/// <param name="attribute">Атрибут, по которому осуществляется поиск</param>
/// <returns>Элемент</returns>
public static IWebElement FindElement(this IWebElement webElement, SearchMethod searchMethod, string attribute)
{
return(searchMethod switch
{
SearchMethod.Tag => webElement.FindElement(By.TagName(attribute)),
SearchMethod.ClassName => webElement.FindElement(By.ClassName(attribute)),
SearchMethod.Id => webElement.FindElement(By.Id(attribute)),
SearchMethod.XPath => webElement.FindElement(By.XPath(attribute)),
SearchMethod.Selector => webElement.FindElement(By.CssSelector(attribute)),
_ => null,
});
private void OnTagSearchRequested(TagBase source, string searchText)
{
Console.WriteLine("Search requested from " + this.tagPanel.Children.IndexOf(source));
SearchSource = source;
if (SearchMethod == null)
{
throw new InvalidOperationException("The tagbox is missing and Action<string> delegate for the SearchMethod");
}
SearchMethod.Invoke(searchText.Trim());
}
static void Main(string[] args)
{
School school = new School();
SearchMethod <People> search = new SearchMethod <People>();
SearchModel <string, People> search1 = new SearchModel <string, People>()
{
Class = "Teacher"
};
SearchModel <string, People> search2 = new SearchModel <string, People>()
{
Class = "Teacher", Property = "Name", Value = "Barna"
};
SearchModel <string, People> search3 = new SearchModel <string, People>()
{
Property = "Status", Value = "student"
};
SearchModel <int, People> search4 = new SearchModel <int, People>()
{
Property = "Age", Value = 12
};
SearchModel <bool, People> search5 = new SearchModel <bool, People> {
Property = "Clever", Value = true
};
string qsearch1 = "?Status=teacher";
string qsearch2 = "?Status=student&&Name=Barna";
string qsearch3 = "?Age=12";
string qsearch4 = "?Age=12&&Status=student&&Clever=false";
//Console.WriteLine("Original list:");
//Printer(school.SchoolMembers);
//Console.WriteLine("Filtered for class:");
//Printer(search1.Filter(school.SchoolMembers));
//Console.WriteLine("Filtered for class & property:");
//Printer(search2.Filter(school.SchoolMembers));
//Console.WriteLine("Filtered for just property:");
//Printer(search3.Filter(school.SchoolMembers));
//Console.WriteLine("Filtered for age property");
//Printer(search4.Filter(school.SchoolMembers));
//Console.WriteLine("Filtered for clever property");
//Printer(search5.Filter(school.SchoolMembers));
Console.WriteLine("query1");
Printer(search.SearchFromQuery(qsearch1, school.SchoolMembers));
Console.WriteLine("query2");
Printer(search.SearchFromQuery(qsearch2, school.SchoolMembers));
Console.WriteLine("query3");
Printer(search.SearchFromQuery(qsearch3, school.SchoolMembers));
Console.WriteLine("query4");
Printer(search.SearchFromQuery(qsearch4, school.SchoolMembers));
Console.ReadKey();
}
/// <summary>
/// suggestion
/// </summary>
/// <param name="query"></param>
/// <returns>only song names</returns>
public async override Task <SongSuggestionContent> GetSongSuggestionAsync(string query)
{
return(await this.GetResponse(new SongSuggestionContent(), SearchMethod.Suggestion(query), (o) =>
{
if (o.HasError)
{
return;
}
suggestion suggestion = (suggestion)JsonConvert.DeserializeObject(o.Value, typeof(suggestion));
o.Query = suggestion.query;
o.Items = suggestion.suggestion_list;
}));
}
public void SolveServer()
{
solver = new DFS();
List <int> cards = communicator.GetCardsFromServer().ToList();
string c1 = cards[0] + "";
string c2 = cards[1] + "";
string c3 = cards[2] + "";
string c4 = cards[3] + "";
solver.acceptInput(new Cards(c1, c2, c3, c4));
solver.search();
PrintOutput(solver.receiveOutput());
}
/// <summary>
/// Public constructor for DistributedSearcher. A DistributedSearcher is defined
/// in XML configuration and is loaded via a custom configuration handler.
/// </summary>
/// <param name="xSection">The Xml definition in the configuration file</param>
public DistributedSearcher(XmlNode xSection)
{
XmlAttributeCollection attributeCollection = xSection.Attributes;
if (attributeCollection == null)
throw new ConfigurationErrorsException("xSection.Attributes invalid: " + Environment.NewLine + xSection.OuterXml);
try
{
this._id = Convert.ToInt32(attributeCollection["id"].Value);
}
catch (Exception e)
{
throw new ConfigurationErrorsException("DistributedSearcher.id invalid: " + Environment.NewLine + xSection.OuterXml + Environment.NewLine + e.Message);
}
try
{
this._eSearchMethod = (SearchMethod)Enum.Parse(typeof(SearchMethod), attributeCollection["SearchMethod"].Value);
}
catch (Exception)
{
throw new ConfigurationErrorsException("DistributedSearcher.SearchMethod invalid: " + Environment.NewLine + xSection.OuterXml);
}
try
{
this._strLocation = attributeCollection["Location"].Value;
}
catch (Exception)
{
throw new ConfigurationErrorsException("DistributedSearcher.Location invalid: " + Environment.NewLine + xSection.OuterXml);
}
if (this.SearchMethod == SearchMethod.Local)
{
//check for file-system existence
if (!Lucene.Net.Index.IndexReader.IndexExists(this.Location))
throw new ConfigurationErrorsException("DistributedSearcher.Location not an index: " + Environment.NewLine + this.Location);
}
else if (this.SearchMethod == SearchMethod.Distributed)
{
//exec ping check if needed
}
}
public TreeNode<StateConfig> findClosest(StateConfig config, SearchMethod search)
{
TreeNode<StateConfig> closestNode = nodeList[0];
float closestDistance = closestNode.content.computeDistanceEuclidean(config);
float thisDistance = -1;
TreeNode<StateConfig> currentNode = null;
for (int i = 0; i < nodeList.Count; i++) {
currentNode = nodeList[i];
if ((thisDistance = currentNode.content.computeDistanceEuclidean(config)) < closestDistance){
closestNode = currentNode;
closestDistance = thisDistance;
}
}
// if (search == SearchMethod.BFS){
// closestNode = findClosestBFS(config);
// } else {
// closestNode = findClosestDFS(config);
// }
return closestNode;
}
/// <summary>
/// Cleanly combines two IEnumerables (possibly null)
/// </summary>
/// <param name="co1">The existing ContentObjects result</param>
/// <param name="co2">The new ContentObjects you would like to add to the result</param>
/// <param name="method">The method by which to join the results (union or intersect)</param>
/// <returns>An IEnumerable containing the combined inputs</returns>
private IEnumerable<ContentObject> combineResults(IEnumerable<ContentObject> existing, IEnumerable<ContentObject> toAdd, SearchMethod method)
{
if (toAdd.Count() > 0)
{
if (existing == null)
existing = toAdd;
else
{
existing = (method == SearchMethod.OR)
? existing.Union(toAdd, _compare)
: existing.Intersect(toAdd, _compare);
}
}
return existing;
}
private void SetSearchButtonsEnabled(SearchMethod method)
{
this.searchData1Button.Enabled = SearchMethod.Method_1 == method;
this.searchData2Button.Enabled = SearchMethod.Method_2 == method;
this.searchData3Button.Enabled = SearchMethod.Method_3 == method;
}
public SearchResult[] Search(Color input, ColorSpace colorSpace, SearchMethod method)
{
Bitmap bmp = new Bitmap(265, 265, PixelFormat.Format32bppArgb);
Graphics gBmp = Graphics.FromImage(bmp);
gBmp.FillRectangle(new SolidBrush(input), 0, 0, 256, 256);
if (colorSpace == ColorSpace.Rgb)
{
return SearchRgb(bmp.GetRgbHistogram(), method);
}
return SearchHsv(bmp.GetHsvHistogram(), method);
}
private SearchResult[] Search(
int[][] input,
Func<int[][], int[][], Func<int[], int[], int, double>, double> diff,
Func<Histogram, int[][]> getHistogram,
SearchMethod method)
{
Func<int[], int[], int, double> compareMethod = Histogram.ChiSquare;
switch (method)
{
case SearchMethod.ChiSquare:
compareMethod = Histogram.ChiSquare;
break;
case SearchMethod.ChiSquare2:
compareMethod = Histogram.ChiSquare2;
break;
case SearchMethod.Correlation:
compareMethod = Histogram.Correlation;
break;
case SearchMethod.Intersection:
compareMethod = Histogram.Intersection;
break;
}
var result = _db.Images
.AsParallel()
.Select(x => new SearchResult(diff(input, getHistogram(x.Histogram), compareMethod), x))
;
if (method == SearchMethod.Correlation || method == SearchMethod.Intersection)
return result.OrderByDescending(x => x.Distance).ToArray();
return result.OrderBy(x => x.Distance).ToArray();
}
/// <summary>
/// Cycle through the search method to the next type
/// </summary>
public void NextSearchType()
{
searchMethod = (SearchMethod)(((int)searchMethod + 1) %
(int)SearchMethod.Max);
}
private SearchResult[] SearchHsv(int[][] input, SearchMethod method)
{
return Search(input, Histogram.HsvChiSquareDistance, x => x.HsvHistogram, method);
}
private SearchResult[] SearchRgb(int[][] input, SearchMethod method)
{
return Search(input, Histogram.RgbDistance, x => x.RgbHistogram, method);
}
private void AppendSearchMethod(ToolStripDropDownItem menuItem, SearchMethod value, string text)
{
var isChecked = Settings.Default.SearchMethods.HasFlag(value);
var item = new ToolStripMenuItem
{
CheckState = isChecked ? CheckState.Checked : CheckState.Unchecked,
Text = text,
Tag = value,
CheckOnClick = true
};
menuItem.DropDownItems.Add(item);
item.CheckedChanged += SearchMethodCheckChanged;
}
public IEnumerable<ContentObject> SearchByFields(NameValueCollection fields, SearchMethod method = SearchMethod.OR)
{
if (fields.Count < 1)
return null;
IEnumerable<ContentObject> results = null;
for (int i = 0; i < fields.Count; i++)
results = combineResults(results, SearchByField(fields.Keys[i], fields[fields.Keys[i]]), method);
return results;
}
public IEnumerable<ContentObject> QuickSearch(IEnumerable<string> terms, SearchMethod method = SearchMethod.OR)
{
if (terms.Count() < 1)
return null;
IEnumerable<ContentObject> results = null;
foreach (string term in terms)
results = combineResults(results, QuickSearch(term), method);
return results;
}
