public Bitmap ApplyFilter(Bitmap image, IFilterParameters filterParameters)
{
matrixFilterParameters = filterParameters as MatrixFilterParameters;
if (matrixFilterParameters == null)
{
throw new ArgumentException();
}
var destImage = new Bitmap(image);
resultImage = new LockBitmap(destImage);
resultImage.LockBits();
sourceImage = new LockBitmap(image);
sourceImage.LockBits();
matrixLength = Convert.ToInt32(Math.Sqrt(matrixFilterParameters.Matrix.Length));
Parallel.For(0, sourceImage.Width, x =>
{
for (int y = 0; y < sourceImage.Height; y++)
{
Wrap(x, y);
}
});
resultImage.UnlockBits();
sourceImage.UnlockBits();
return destImage;
}
public override IQueryable <Thing> ApplyListSearchTerm(IQueryable <Thing> query,
IFilterParameters parameters)
{
var sql = new List <string> {
"SELECT * FROM [dbo].[Things] WHERE 1=1"
};
var sqlParams = new List <SqlParameter>();
if (false == string.IsNullOrWhiteSpace(FooPart))
{
sql.Add("[Foo] LIKE '%' + @FooPart + '%' ");
sqlParams.Add(new SqlParameter("FooPart", FooPart));
}
if (false == string.IsNullOrWhiteSpace(BarPart))
{
sql.Add("[Bar] LIKE '%' + @BarPart + '%' ");
sqlParams.Add(new SqlParameter("BarPart", BarPart));
}
return(sql.Count == 1
? Enumerable.Empty <Thing>().AsQueryable()
#pragma warning disable EF1000 // Possible SQL injection vulnerability.
: query.FromSql(string.Join(" AND ", sql), sqlParams.Cast <object>().ToArray()));
#pragma warning restore EF1000 // Possible SQL injection vulnerability.
}
public void ExecuteFilter()
{
if (Parameters is null)
{
Parameters = CreateDefaultParameters();
}
ResultImage = null;
IsLoading = true;
var inputImage = _imageloader.LoadedImage.ToBitmap();
if (SelectedFilterType == FilterType.GaussianBlur)
{
var samplingScale = (int)Math.Ceiling(Math.Max(inputImage.Width, inputImage.Height) * 1.0 / SampleCountPerDimension);
Task.Run(() =>
{
ResultImage = new GaussianBlurTaskManager(inputImage).UseDownsampling(samplingScale)
.RunAll(Environment.ProcessorCount, _kernel)
.WaitForResult()
.ToBitmapImage(ImageFormat.Jpeg);
IsLoading = false;
});
}
else
{
Task.Run(() =>
{
ResultImage = new AdaptiveThresholding().Execute(_thresholdingParameters, inputImage)
.ToBitmapImage(ImageFormat.Jpeg);
IsLoading = false;
});
}
}
private string ToSql(ISqlFormatter sql, IList <IColumn> select,
IFilterParameters filterParams, IEnumerable <Filter> outerFilters,
long skip, int take)
{
if (Aggregations.Count == 1)
{
return(Aggregations[0].ToSql(sql, select, outerFilters.Concat(Filters), filterParams, OrderBy, skip, take));
}
var ordering = "a0.Value0 desc";
if (select != null && OrderBy.Count != 0)
{
ordering = string.Join(", ", OrderBy.Select(FindOrderingColumn));
}
return(_aggregatedTemplate(new
{
skipAndTake = sql.SkipAndTake(skip, take),
Aggregations = Aggregations.Select(x =>
x.ToSql(sql, select, outerFilters.Concat(Filters), filterParams)),
Select = select,
ordering
}));
}
public string ToSql(
ISqlFormatter sql,
IEnumerable <IColumn> selectColumns,
IEnumerable <Filter> outerFilters,
IFilterParameters filterParams,
IEnumerable <Ordering> orderings = null,
long?skip = null,
int?take = null)
{
var joins = new Joins();
var selects = selectColumns?.Select((c, i) =>
$"{sql.IdentifierPair(joins[c.Table], c.DbName)} Select{i}").ToList()
?? new List <string>();
var aggColumn = Column != null ? $"{Function}({joins.Aliased(Column, sql)})" : null;
if (aggColumn != null)
{
selects.Add($"{aggColumn} Value0");
}
if (selects.Count == 0)
{
throw new InvalidOperationException("Must select something");
}
var filters = outerFilters.Concat(Filters).Select(f => new
{
Column = joins.Aliased(f.Column, sql),
f.Operator,
Param = filterParams[f]
})
.ToList();
var groupBy = selectColumns?.Select(x => new
{
Part = joins.Aliased(x, sql)
})
.ToList();
var skipAndTake = skip != null && take != null
? sql.SkipAndTake(skip.Value, take.Value)
: null;
var orderBy = skipAndTake == null ? null :
orderings.Any() ? string.Join(", ", orderings.Select(x => $"{joins.Aliased(x.Column, sql)} {x.Direction}")) :
aggColumn != null ? $"{aggColumn} desc" :
null;
return(_template(new
{
selects,
filters,
joins = joins.ToSql(sql),
groupBy,
orderBy,
skipAndTake
}));
}
public virtual async Task <ItemResult <int> > GetCountAsync(IFilterParameters parameters)
{
var query = GetQuery(parameters);
query = ApplyListFiltering(query, parameters);
return(new ItemResult <int>(await GetListTotalCountAsync(query, parameters)));
}
public string ToSql(ISqlFormatter sql,
IFilterParameters filterParams,
IEnumerable <Filter> outerFilters)
{
var result = ToSql(sql, Select, filterParams, outerFilters, Skip, Take);
if (Totals)
{
result += ";" + ToSql(sql, null, filterParams, outerFilters, 0, 1);
}
return(result);
}
/// <summary>
/// Applies the "filter.propertyName=exactValue" filters to a query.
/// These filters may be set when making a list request, and are found in ListParameters.Filters.
/// This is called by ApplyListFiltering when constructing a list result.
/// </summary>
/// <param name="query">The query to filter.</param>
/// <param name="parameters">The parameters by which to filter.</param>
/// <returns>The new query with additional filtering applied.</returns>
public virtual IQueryable <T> ApplyListPropertyFilters(IQueryable <T> query, IFilterParameters parameters)
{
// Add key value pairs where = is used.
foreach (var clause in parameters.Filter)
{
var prop = ClassViewModel.PropertyByName(clause.Key);
if (prop != null &&
prop.IsUrlFilterParameter &&
prop.SecurityInfo.IsReadable(User))
{
query = ApplyListPropertyFilter(query, prop, clause.Value);
}
}
return(query);
}
/// <summary>
/// Evaluate the given query to determine the total count of items to report to the client.
/// </summary>
/// <param name="query">The filtered query from which to obtain a count.</param>
/// <param name="parameters">The parameters by which to query.</param>
/// <returns>The total count of items represented by the query.</returns>
public virtual Task <int> GetListTotalCountAsync(IQueryable <T> query, IFilterParameters parameters)
{
var canUseAsync = CanEvalQueryAsynchronously(query);
return(canUseAsync ? query.CountAsync() : Task.FromResult(query.Count()));
}
/// <summary>
/// Applies all filtering that is done when getting a list of data
/// (or metadata about a particular set of filters, like a count).
/// This includes ApplyListPropertyFilters and ApplyListSearchTerm.
/// This is called by GetListAsync when constructing a list result.
/// </summary>
/// <param name="query">The query to filter.</param>
/// <param name="parameters">The parameters by which to filter.</param>
/// <returns>The new query with additional filtering applied.</returns>
public virtual IQueryable <T> ApplyListFiltering(IQueryable <T> query, IFilterParameters parameters)
{
query = ApplyListPropertyFilters(query, parameters);
query = ApplyListSearchTerm(query, parameters);
return(query);
}
/// <summary>
/// Applies a filter to the query based on the search term recieved from the client.
/// This search term is found in parameters.Search.
/// This is called by ApplyListFiltering when constructing a list result.
/// </summary>
/// <param name="query">The query to filter.</param>
/// <param name="parameters"></param>
/// <returns>The new query with additional filtering applied.</returns>
public virtual IQueryable <T> ApplyListSearchTerm(IQueryable <T> query, IFilterParameters parameters)
{
var searchTerm = parameters.Search;
// Add general search filters.
// These search specified fields in the class
if (string.IsNullOrWhiteSpace(searchTerm))
{
return(query);
}
// See if the user has specified a field with a colon and search on that first
if (searchTerm.Contains(":"))
{
var fieldValueParts = searchTerm.Split(new string[] { ":" }, StringSplitOptions.None);
var field = fieldValueParts[0].Trim();
var value = fieldValueParts[1].Trim();
var prop = ClassViewModel.ClientProperties.FirstOrDefault(f =>
string.Compare(f.Name, field, true) == 0 ||
string.Compare(f.DisplayName, field, true) == 0);
if (prop != null && !string.IsNullOrWhiteSpace(value))
{
var expressions = prop
.SearchProperties(ClassViewModel, maxDepth: 1, force: true)
.SelectMany(p => p.GetLinqDynamicSearchStatements(Context.User, Context.TimeZone, "it", value))
.Select(t => t.statement)
.ToList();
// Join these together with an 'or'
if (expressions.Any())
{
string finalSearchClause = string.Join(" || ", expressions);
return(query.Where(finalSearchClause));
}
}
}
var completeSearchClauses = new List <string>();
// For all searchable properties where SearchIsSplitOnSpaces is true,
// we require that each word in the search terms yields at least one match.
// This allows search results to become more refined as more words are typed in.
// For example, when searching on properties (FirstName, LastName) with input "steve steverson",
// we require that "steve" match either a first name or last name, and "steverson" match a first name or last name
// of the same records. This will yield people named "steve steverson" or "steverson steve".
var splitOnStringTermClauses = new List <string>();
var terms = searchTerm
.Split(new string[] { " ", "," }, StringSplitOptions.RemoveEmptyEntries)
.Select(term => term.Trim())
.Distinct()
.Where(term => !string.IsNullOrWhiteSpace(term))
.Take(MaxSearchTerms);
foreach (var termWord in terms)
{
var splitOnStringClauses = ClassViewModel
.SearchProperties(ClassViewModel)
.SelectMany(p => p.GetLinqDynamicSearchStatements(Context.User, Context.TimeZone, "it", termWord))
.Where(f => f.property.SearchIsSplitOnSpaces)
.Select(t => t.statement)
.ToList();
// For the given term word, allow any of the properties (so we join clauses with OR)
// to match the term word.
if (splitOnStringClauses.Any())
{
splitOnStringTermClauses.Add("(" + string.Join(" || ", splitOnStringClauses) + ")");
}
}
// Require each "word clause"
if (splitOnStringTermClauses.Any())
{
completeSearchClauses.Add("( " + string.Join(" && ", splitOnStringTermClauses) + " )");
}
// For all searchable properties where SearchIsSplitOnSpaces is false,
// we only require that the entire search term match at least one of these properties.
var searchClauses = ClassViewModel
.SearchProperties(ClassViewModel)
.SelectMany(p => p.GetLinqDynamicSearchStatements(Context.User, Context.TimeZone, "it", searchTerm))
.Where(f => !f.property.SearchIsSplitOnSpaces)
.Select(t => t.statement)
.ToList();
completeSearchClauses.AddRange(searchClauses);
if (completeSearchClauses.Any())
{
string finalSearchClause = string.Join(" || ", completeSearchClauses);
query = query.Where(finalSearchClause);
}
else
{
// A search term was specified (we didn't return early from this method),
// but we didn't find any valid properties to search on (we didn't come up with any clauses).
// We should therefore return no results since the search term entered can't come up with any results.
query = query.Where(q => false);
}
// Don't put any other code down here. The property:value search handling returns early
// if it finds a match. If you need code down here, refactor that part.
return(query);
}
/// <summary>
/// Read method,
/// gets a list of VehicleMakes from Generic Repository,
/// does sorting, filtering and pagging.
/// </summary>
/// <param name="sortParameters">Has 2 properties: Sort and Sort Direction.</param>
/// <param name="filterParameters">Has 2 properties: Search and MakeId.</param>
/// <param name="pageParameters">Has 2 properties: Page and PageSize.</param>
/// <returns>Returns a list of paged, sorted and filtered IVehicleMake.</returns>
public async Task <IPagedResult <IVehicleMake> > GetVehicleMakesAsync(ISortParameters sortParameters, IFilterParameters filterParameters, IPageParameters pageParameters)
{
IQueryable <VehicleMakeEntity> vehicleMakeList;
PagedResult <IVehicleMake> PagedVehicleMake = new PagedResult <IVehicleMake>();
if (!string.IsNullOrEmpty(filterParameters.Search))
{
vehicleMakeList = Repository.GetVehiclesAsync().Where(x => x.Abrv.ToUpper() == filterParameters.Search.ToUpper() || x.Name.ToUpper().Contains(filterParameters.Search.ToUpper())).OrderBy(x => x.Id).AsQueryable();
}
else
{
vehicleMakeList = Repository.GetVehiclesAsync().OrderBy(x => x.Id);
}
if (!string.IsNullOrEmpty(sortParameters.Sort))
{
if (sortParameters.Sort.ToUpper() == "NAME")
{
vehicleMakeList = vehicleMakeList.OrderBy(x => x.Name).AsQueryable();
}
else if (sortParameters.Sort.ToUpper() == "ABRV")
{
vehicleMakeList = vehicleMakeList.OrderBy(x => x.Abrv).AsQueryable();
}
}
else
{
vehicleMakeList = vehicleMakeList.OrderBy(x => x.Id).AsQueryable();
}
if (sortParameters.SortDirection.ToUpper() == "DESCENDING")
{
vehicleMakeList.Reverse();
}
if (pageParameters.PageSize != 0)
{
int?skipAmount;
if (pageParameters.Page == 0 || pageParameters.Page == null)
{
skipAmount = 0;
}
else
{
skipAmount = (pageParameters.PageSize * (pageParameters.Page - 1));
}
var totalNumberOfRecords = vehicleMakeList.Count();
vehicleMakeList = vehicleMakeList.Skip((int)skipAmount).Take(pageParameters.PageSize).AsQueryable();
var mod = totalNumberOfRecords % pageParameters.PageSize;
var totalPageCount = (totalNumberOfRecords / pageParameters.PageSize) + (mod == 0 ? 0 : 1);
var Results = AutoMapper.Mapper.Map <IEnumerable <IVehicleMake> >(vehicleMakeList.ToList());
PagedVehicleMake.PageNumber = (int)pageParameters.Page;
PagedVehicleMake.PageSize = pageParameters.PageSize;
PagedVehicleMake.TotalNumberOfPages = totalPageCount;
if (sortParameters.SortDirection != null)
{
if (sortParameters.SortDirection.ToUpper() == "DESCENDING")
{
Results = Results.Reverse();
}
}
PagedVehicleMake.Results = Results;
}
else
{
PagedVehicleMake.PageNumber = 0;
PagedVehicleMake.PageSize = 0;
PagedVehicleMake.TotalNumberOfPages = 0;
PagedVehicleMake.Results = AutoMapper.Mapper.Map <IEnumerable <IVehicleMake> >(vehicleMakeList.ToList());
}
return(PagedVehicleMake);
}
public async Task <IPagedList <VehicleMakeEntity> > GetVehicleMakesAsync(ISortParameters sort, IFilterParameters filter, IPageParameters pagep)
{
//Search
if (!string.IsNullOrEmpty(filter.Search))
{
vehicleMakes = repository.GetAll().Where(s => s.Name.ToUpper().StartsWith(filter.Search.ToUpper())).AsQueryable();
}
else
{
vehicleMakes = repository.GetAll().AsQueryable();
}
//OrderBy
switch (sort.SortBy?.ToUpper())
{
case "NAME":
vehicleMakes = vehicleMakes.OrderBy(s => s.Name).AsQueryable();
break;
case "ID":
vehicleMakes = vehicleMakes.OrderBy(s => s.Id).AsQueryable();
break;
default:
vehicleMakes = vehicleMakes.OrderBy(s => s.Id).AsQueryable();
break;
}
//ORDER BY DESCENDING
if (sort.SortOrder?.ToUpper() == "DESC")
{
vehicleMakes = vehicleMakes.OrderByDescending(s => s.Name).AsQueryable();
vehicleMakes = vehicleMakes.OrderByDescending(s => s.Id).AsQueryable();
}
;
return(vehicleMakes.ToPagedList(pagep.Page, pagep.PageSize));
}
public SavitzyGolaySmoothing(IFilterParameters filterParameters)
{
this.filterParameters = filterParameters;
computedCoefficients = this.filterParameters.Coefficients.Reverse().Concat(this.filterParameters.Coefficients.Skip(1)).ToArray();
}
public IPagedList <IVehicleMake> GetVehicleMakePaged(ISortParameters sortParameters, IFilterParameters filterParameters, IPageParameters pageParameters)
{
var vehicleMakeList = context.VehicleMakes.AsEnumerable();
switch (sortParameters.Sort)
{
case "Name":
vehicleMakeList = vehicleMakeList.OrderBy(c => c.Name);
break;
case "Abrv":
vehicleMakeList = vehicleMakeList.OrderBy(c => c.Abrv);
break;
default:
vehicleMakeList = vehicleMakeList.OrderBy(c => c.Id);
break;
}
if (!string.IsNullOrEmpty(filterParameters.Search))
{
vehicleMakeList = vehicleMakeList.Where(c => c.Name.ToUpper().Contains(filterParameters.Search.ToUpper()));
}
if (sortParameters.Direction == "Descending")
{
vehicleMakeList = vehicleMakeList.Reverse();
}
return(vehicleMakeList.ToPagedList(pageParameters.Page, pageParameters.PageSize));
}
/// <summary>
/// Read method,
/// gets a list of VehicleModels from VehicleModel Repository,
/// does sorting, filtering and pagging.
/// </summary>
/// <param name="sortParameters">Has 2 properties: Sort and Sort Direction.</param>
/// <param name="filterParameters">Has 2 properties: Search and MakeId.</param>
/// <param name="pageParameters">Has 2 properties: Page and PageSize.</param>
/// <returns>Retuns a list of paged, sorted and filtered IVehicleModel.</returns>
public async Task <IPagedResult <IVehicleModel> > GetVehicleModelsAsync(ISortParameters sortParameters, IFilterParameters filterParameters, IPageParameters pageParameters)
{
return(await repository.GetVehicleModelsAsync(sortParameters, filterParameters, pageParameters));
}
public async Task <IPagedList <VehicleMake> > GetVehicleMakesAsync(ISortParameters sort, IFilterParameters filter, IPageParameters pagep)
{
var makeList = await _repository.GetVehicleMakesAsync(sort, filter, pagep);
var makeVMList = AutoMapper.Mapper.Map <IEnumerable <VehicleMake> >(makeList);
return(new StaticPagedList <VehicleMake>(makeVMList, makeList.GetMetaData()));
}
public Expression <Func <T, bool> > ComposeFilterExpressionFromParameters(IFilterParameters parameters)
{
return(arg => true);
}
public Bitmap ApplyFilter(Bitmap image, IFilterParameters filterParameters)
{
var parameters = filterParameters as ContrastFilterParameters;
if(parameters == null)
{
throw new ArgumentException();
}
int threshold = parameters.Threshold;
BitmapData sourceData = image.LockBits(new Rectangle(0, 0,
image.Width, image.Height),
ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height];
Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length);
image.UnlockBits(sourceData);
double contrastLevel = Math.Pow((100.0 + threshold) / 100.0, 2);
double blue = 0;
double green = 0;
double red = 0;
for (int k = 0; k + 4 < pixelBuffer.Length; k += 4)
{
blue = ((((pixelBuffer[k] / 255.0) - 0.5) *
contrastLevel) + 0.5) * 255.0;
green = ((((pixelBuffer[k + 1] / 255.0) - 0.5) *
contrastLevel) + 0.5) * 255.0;
red = ((((pixelBuffer[k + 2] / 255.0) - 0.5) *
contrastLevel) + 0.5) * 255.0;
if (blue > 255)
{ blue = 255; }
else if (blue < 0)
{ blue = 0; }
if (green > 255)
{ green = 255; }
else if (green < 0)
{ green = 0; }
if (red > 255)
{ red = 255; }
else if (red < 0)
{ red = 0; }
pixelBuffer[k] = (byte)blue;
pixelBuffer[k + 1] = (byte)green;
pixelBuffer[k + 2] = (byte)red;
}
Bitmap resultBitmap = new Bitmap(image.Width, image.Height);
BitmapData resultData = resultBitmap.LockBits(new Rectangle(0, 0,
resultBitmap.Width, resultBitmap.Height),
ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
Marshal.Copy(pixelBuffer, 0, resultData.Scan0, pixelBuffer.Length);
resultBitmap.UnlockBits(resultData);
return resultBitmap;
}
public Bitmap ApplyFilter(Bitmap image, IFilterParameters filterParameters)
{
var param = filterParameters as GausianFilterParameters;
if (param == null)
{
throw new ArgumentException("Parameters object must implement IFilterParameters");
}
var windowSize = (int)Math.Ceiling(param.Sigma * 3);
var window = InitializeWindow(param.Sigma);
var img = new LockBitmap(image);
var dest = new Bitmap(image);
img.LockBits();
var destImage = new LockBitmap(dest);
destImage.LockBits();
Parallel.For(0, img.Width, x =>
{
Color[] tmp = new Color[img.Height];
for (var y = 0; y < img.Height; y++)
{
var sum = 0.0;
var r = 0.0;
var g = 0.0;
var b = 0.0;
for (var i = 0; i < window.Length; i++)
{
var l = x + i - windowSize;
if (l >= 0 && l < img.Width)
{
var sourceColor = img.GetPixel(l, y);
r += sourceColor.R * window[i];
g += sourceColor.G * window[i];
b += sourceColor.B * window[i];
sum += window[i];
}
}
tmp[y] = Color.FromArgb((r / sum).GetValidColorComponent(), (g / sum).GetValidColorComponent(),
(b / sum).GetValidColorComponent());
}
for (var i = 0; i < img.Height; i++)
{
destImage.SetPixel(x, i, tmp[i]);
}
});
Parallel.For(0, img.Height, y =>
{
Color[] tmp = new Color[img.Width];
for (var x = 0; x < img.Width; x++)
{
var sum = 0.0;
var r = 0.0;
var g = 0.0;
var b = 0.0;
for (var i = 0; i < window.Length; i++)
{
var l = y + i - windowSize;
if (l >= 0 && l < img.Height)
{
var sourceColor = destImage.GetPixel(x, l);
r += sourceColor.R * window[i];
g += sourceColor.G * window[i];
b += sourceColor.B * window[i];
sum += window[i];
}
}
tmp[x] = Color.FromArgb((r / sum).GetValidColorComponent(), (g / sum).GetValidColorComponent(),
(b / sum).GetValidColorComponent());
}
for (var i = 0; i < img.Width; i++)
{
img.SetPixel(i, y, tmp[i]);
}
});
img.UnlockBits();
destImage.UnlockBits();
return image;
}
public IFilter Create(IFilterParameters parameters)
{
Debug.Assert(FilterParameters.AcceptsParameters);
return(_creator(parameters));
}
