/// <summary>
/// Get the depth type of the image
/// </summary>
/// <param name="image">The image to apply reflection on</param>
/// <returns>The depth type of the image</returns>
public static Type GetTypeOfDepth(IImage image)
{
return
Toolbox
.GetBaseType(image.GetType(), "Image`2")
.GetGenericArguments()[1];
}
public void Save(IImage image, IFile file)
{
var actual = ((ImageAdapter)image).Image;
using (var stream = file.Open(FileLockMode.ReadWrite, FileOpenMode.Recreate)) {
actual.Save(stream, this.codec, this.parameters);
}
}
public IImage Handle(IImage src)
{
m_cacheResults.Clear();
if (src == null) return null;
if (Enable == true)
{
try
{
this.m_inputImage = src;
this.m_cacheResults.Add(this.CreateInput(this.m_inputImage));
this.m_outputImage = this.HandleCore(src);
if (this.m_outputImage != null)
{
this.m_cacheResults.Add(this.CreateOutput(this.m_outputImage));
}
return this.m_outputImage;
}
catch (Exception ex)
{
this.m_cacheResults.Add(this.CreateExceptionResult(ex));
return this.m_outputImage;
}
finally
{
}
}
else return src;
}
protected override IImage HandleCore(IImage src)
{
// Bitmap dst = src.Clone(new Rectangle(0,0,src.Width,src.Height), src.PixelFormat) as Bitmap;
// m_filter.ApplyInPlace(dst);
// return dst;
throw new NotImplementedException();
}
public static unsafe void ConvertByteToDouble(IImage src, IImage dest)
{
int nChannels = src.ColorInfo.NumberOfChannels;
int elemWidth = src.Width * nChannels;
int height = src.Height;
int srcStride = src.Stride;
int destStride = dest.Stride;
for (int channel = 0; channel < src.ColorInfo.NumberOfChannels; channel++)
{
byte* srcPtr = (byte*)src.ImageData + channel;
double* destPtr = (double*)dest.ImageData + channel;
for (int r = 0; r < height; r++)
{
for (int c = 0; c < elemWidth; c += nChannels)
{
destPtr[c] = srcPtr[c];
}
srcPtr += srcStride / sizeof(byte);
destPtr += destStride / sizeof(double);
}
}
}
public int Recognize(IImage image)
{
var discretizedImage = discretizer.Discretize(image);
var activeNeuron = classifier.Classify(discretizedImage);
var cluster = mapper.Map(activeNeuron);
return cluster;
}
private static ISprite getDefaultSprite(IImage image, IGraphicsFactory factory)
{
ISprite sprite = factory.GetSprite();
sprite.Image = image;
sprite.Location = AGSLocation.Empty();
return sprite;
}
public static ProcessorResult CreateOutput(IProcessor pro, IImage output)
{
ProcessorResult r = new ProcessorResult();
r.Result = output == null ? null : output.ToBitmap();
r.Name = "输出图像";
return r;
}
public EventButton(string text, int count, EventType eventType, IImage icon)
{
Count = count;
Text = text;
Event = eventType;
Icon = icon;
}
/// <summary>
/// see: http://stackoverflow.com/questions/3018313/algorithm-to-convert-rgb-to-hsv-and-hsv-to-rgb
/// and: http://www.cbusforums.com/forums/showthread.php?t=8657
/// range for HSV is H:[0-180], S:[0-255], V:[0-255]
/// </summary>
public static unsafe void ConvertHsvToBgr_Byte(IImage src, IImage dest)
{
Hsv8* srcPtr = (Hsv8*)src.ImageData;
Bgr8* dstPtr = (Bgr8*)dest.ImageData;
int width = src.Width;
int height = src.Height;
int srcShift = src.Stride - width * sizeof(Hsv8); //DO NOT divide with sizeof(Bgr8) as reminder may not be 0!!!
int dstShift = dest.Stride - width * sizeof(Bgr8);
for (int row = 0; row < height; row++)
{
for (int col = 0; col < width; col++)
{
Hsv8.ConvertHsvToBgr(srcPtr, dstPtr);
srcPtr++;
dstPtr++;
}
srcPtr = (Hsv8*)((byte*)srcPtr + srcShift);
dstPtr = (Bgr8*)((byte*)dstPtr + dstShift);
}
}
public void HandleFindResults(IImage image, IEnumerable<IFindResult> results)
{
foreach (var selectedArea in results)
{
if (selectedArea.Points.Count >= 2)
{
var rand = new Random();
var pixel = _pixels[rand.Next(_pixels.Length - 1)];
DrawLineAlgorithm.PlotFunction plotFunction = (x, y) =>
{
if (x < image.Width && y < image.Height && x >= 0 && y >= 0)
{
image.SetPixel(x, y, pixel);
}
return true;
};
var firstPoint = selectedArea.Points[0];
var previousPoint = firstPoint;
for (int i = 1; i < selectedArea.Points.Count; i++)
{
var currentPoint = selectedArea.Points[i];
DrawLineAlgorithm.Line(previousPoint.X, previousPoint.Y, currentPoint.X, currentPoint.Y, plotFunction);
previousPoint = currentPoint;
}
if (selectedArea.Points.Count > 2)
{
var lastPoint = selectedArea.Points[selectedArea.Points.Count - 1];
DrawLineAlgorithm.Line(lastPoint.X, lastPoint.Y, firstPoint.X, firstPoint.Y, plotFunction);
}
}
}
}
public static TColourFormat GetFormat(IImage image)
{
Image<Gray, byte> ImageL8 = image as Image<Gray, byte>;
if (ImageL8 != null)
return TColourFormat.L8;
Image<Gray, ushort> ImageL16 = image as Image<Gray, ushort>;
if (ImageL16 != null)
return TColourFormat.L16;
Image<Rgb, byte> ImageRGB8 = image as Image<Rgb, byte>;
if (ImageRGB8 != null)
return TColourFormat.RGB8;
//camera captures seem to arrive as bgr even though rgb
//may need to revisit this later on
Image<Bgr, byte> ImageBGR8 = image as Image<Bgr, byte>;
if (ImageBGR8 != null)
return TColourFormat.RGB8;
Image<Rgb, float> ImageRGB32F = image as Image<Rgb, float>;
if (ImageRGB32F != null)
return TColourFormat.RGB32F;
Image<Rgba, byte> ImageRGBA8 = image as Image<Rgba, byte>;
if (ImageRGBA8 != null)
return TColourFormat.RGBA8;
return TColourFormat.UnInitialised;
}
public Task<IProcessServiceResult> ProcessImageAsync(string processorName, IImage image)
{
var result = new ImageProcessServiceResult();
var processor = _processors.FirstOrDefault(p => p.Name == processorName);
if (processor != null)
{
try
{
var imageForProcessing = image.Clone();
processor.ProcessImage(imageForProcessing);
result.ProcessedImage = imageForProcessing;
result.Successful = true;
}
catch (Exception e)
{
result.Successful = false;
result.ErrorMessage = e.Message;
}
}
else
{
result.Successful = false;
result.ErrorMessage = $"Can't find processor with name {processorName}";
}
return Task.FromResult((IProcessServiceResult)result);
}
/// <summary>
/// Display the histograms of the specific image
/// </summary>
/// <param name="image">The image to retrieve hostigram from</param>
/// <param name="numberOfBins">The numebr of bins in the histogram</param>
public static void Show(IImage image, int numberOfBins)
{
HistogramViewer viewer = new HistogramViewer();
viewer.HistogramCtrl.GenerateHistograms(image, numberOfBins);
viewer.HistogramCtrl.Refresh();
viewer.Show();
}
public IEnumerable<Region2D> GetResult(IImage source, FacePartParameter parameter)
{
if (source is Image<Gray, byte> == false)
{
return null;
}
Size size = parameter == null
? Size.Empty
: new Size(parameter.MinWidth, parameter.MinHeight);
IEnumerable<Region2D> ret;
if (parameter.Region == null)
{
ret = Detect((Image<Gray, byte>)source, size).Select(item => item.rect.ToRegion()).ToList();
}
else
{
using (var sourceCrop = ((Image<Gray, byte>)source).GetSubRect(parameter.Region.ToRectangle()))
{
ret = Detect(sourceCrop, size).Select(item => item.rect.ToRegion()).ToList();
}
}
return ret;
}
public static unsafe void ConvertIntToFloat(IImage src, IImage dest)
{
int nChannels = src.ColorInfo.NumberOfChannels;
int elemWidth = src.Width * nChannels;
int height = src.Height;
int srcStride = src.Stride;
int destStride = dest.Stride;
for (int channel = 0; channel < src.ColorInfo.NumberOfChannels; channel++)
{
int* srcPtr = (int*)src.ImageData + channel;
float* destPtr = (float*)dest.ImageData + channel;
for (int r = 0; r < height; r++)
{
for (int c = 0; c < elemWidth; c += nChannels)
{
destPtr[c] = srcPtr[c];
}
srcPtr += srcStride / sizeof(int);
destPtr += destStride / sizeof(float);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="image"></param>
public override void ApplyToImage(IImage image)
{
if (image.Width <= this.Width || image.Height <= this.Height)
return;
base.ApplyToImage(image);
}
public void SetImage(IImage image)
{
#region display the size of the image
Size size = image.Size;
widthTextbox.Text = size.Width.ToString();
heightTextBox.Text = size.Height.ToString();
#endregion
#region display the color type of the image
Type colorType = Reflection.ReflectIImage.GetTypeOfColor(image);
Object[] colorAttributes = colorType.GetCustomAttributes(typeof(ColorInfoAttribute), true);
if (colorAttributes.Length > 0)
{
ColorInfoAttribute info = (ColorInfoAttribute)colorAttributes[0];
typeOfColorTexbox.Text = info.ConversionCodename;
}
else
{
typeOfColorTexbox.Text = Properties.StringTable.Unknown;
}
Type colorDepth = Reflection.ReflectIImage.GetTypeOfDepth(image);
typeOfDepthTextBox.Text = colorDepth.Name;
#endregion
UpdateHistogram();
UpdateZoomScale();
}
public IImageCacheEntry GetImage(IImage image, int decodeWidth = 300, int decodeHeight = 300)
{
string cacheKey = "ImageCacheService_" + image.ID + "_" + decodeWidth + "x" + decodeHeight;
var entry = _cache.Get(cacheKey) as IImageCacheEntry;
if (entry == null)
{
string filePath;
if (TryGetFilePath(image.ID, out filePath))
{
entry = new DiskImageCacheEntry(
image.ID,
filePath,
decodeWidth,
decodeHeight);
_cache.Add(cacheKey, entry, new CacheItemPolicy { SlidingExpiration = TimeSpan.FromSeconds(30) });
}
else
{
if (!string.IsNullOrEmpty(filePath))
{
entry = new FirstTimeImageCacheEntry(image, filePath, decodeWidth, decodeHeight);
}
}
}
return entry;
}
public SavedTreeNode(IImage image, string fullname, string text)
: base(null)
{
base.IconImage = image;
FullName = fullname;
Text = text;
}
public IntHistogram(IImage image, string title, int capacity)
{
this.capacity = capacity;
this.image = image;
Max = 0;
Title = title;
}
protected override IImage HandleCore(IImage src)
{
throw new NotImplementedException();
//IImage dst = null;
//if (src.PixelFormat == System.Drawing.Imaging.PixelFormat.Format8bppIndexed)
//{
// m_filter = new HoughLineTransformation();
// if (StepsPerDegree > 10) StepsPerDegree = 10;
// else if (StepsPerDegree < 1) StepsPerDegree = 1;
// if (LocalPeakRadius > 10) LocalPeakRadius = 10;
// else if (LocalPeakRadius < 1) LocalPeakRadius = 1;
// m_filter.StepsPerDegree = this.StepsPerDegree;
// m_filter.LocalPeakRadius = this.LocalPeakRadius;
// m_filter.ProcessImage(src);
// WriteHoughLine();
// dst = m_filter.ToBitmap();
//}
//else
//{
// dst = src.Clone() as Bitmap;
//}
//IImage dst;
}
/// <summary>
/// Adds the frame to the animation.
/// </summary>
/// <param name="frame">Frame.</param>
/// <param name="duration">Duration.</param>
public void AddFrame(IImage frame, int duration)
{
lock (this) {
frames.Add (new AnimFrame(frame, duration));
totalDuration += duration;
}
}
public override void Start()
{
base.Start();
IStack stack = Platform.Current.Create<IStack>();
ILabel lblLabel = Platform.Current.Create<ILabel>();
lblLabel.Text = "View an image from Url";
lblLabel.Height = 30;
stack.Children.Add(lblLabel);
IImageButton imgbtn = Platform.Current.Create<IImageButton>();
imgbtn.LoadFromUrl(new Uri("http://okhosting.com/wp-content/uploads/2016/02/okhosting-150x150.png"));
imgbtn.Height = 100;
imgbtn.Width = 100;
imgbtn.Click += CmdViewImage_Click;
stack.Children.Add(imgbtn);
imgPicture = Platform.Current.Create<IImage>();
imgPicture.LoadFromUrl(new Uri("http://www.patycantu.com/wp-content/uploads/2014/07/91.jpg"));
imgPicture.Height = 250;
imgPicture.Width = 600;
imgPicture.Visible = false;
stack.Children.Add(imgPicture);
IButton cmdClose = Platform.Current.Create<IButton>();
cmdClose.Text = "Close";
cmdClose.Click += CmdClose_Click;
stack.Children.Add(cmdClose);
Platform.Current.Page.Title = "Test label";
Platform.Current.Page.Content = stack;
}
private unsafe static void phase_Double(IImage imageX, IImage imageY, IImage magnitudeImage)
{
int width = imageX.Width;
int height = imageX.Height;
int srcAOffset = imageX.Stride - width * sizeof(double);
int srcBOffset = imageY.Stride - width * sizeof(double);
int dstOffset = magnitudeImage.Stride - width * sizeof(double);
double* srcXPtr = (double*)imageX.ImageData;
double* srcYPtr = (double*)imageY.ImageData;
double* dstPtr = (double*)magnitudeImage.ImageData;
for (int row = 0; row < height; row++)
{
for (int col = 0; col < width; col++)
{
*dstPtr = (double)System.Math.Atan2(*srcYPtr, *srcXPtr);
srcXPtr++;
srcYPtr++;
dstPtr++;
}
srcXPtr = (double*)((byte*)srcXPtr + srcAOffset);
srcYPtr = (double*)((byte*)srcYPtr + srcBOffset);
dstPtr = (double*)((byte*)dstPtr + dstOffset);
}
}
public void DrawImage (IImage image, Rect frame, double alpha = 1.0)
{
var ch = GetChild (ChildType.Image);
var s = (Shapes.Rectangle)ch.Shape;
s.Width = frame.Width;
s.Height = frame.Height;
}
private unsafe static void findNonZero_Float(IImage img, out List<Point> locations, out IList values)
{
locations = new List<Point>();
var _values = new List<float>();
float* ptr = (float*)img.ImageData;
int stride = img.Stride;
int width = img.Width;
int height = img.Height;
for (int row = 0; row < height; row++)
{
for (int col = 0; col < width; col++)
{
var val = ptr[col];
if (val != 0)
{
locations.Add(new Point(col, row));
_values.Add(val);
}
}
ptr = (float*)((byte*)ptr + stride);
}
values = _values;
}
/// <summary>
/// Predict the label of the image
/// </summary>
/// <param name="image">The image where prediction will be based on</param>
/// <returns>The prediction label</returns>
public PredictionResult Predict(IImage image)
{
int label = -1;
double distance = -1;
CvInvoke.CvFaceRecognizerPredict(_ptr, image.Ptr, ref label, ref distance);
return new PredictionResult() { Label = label, Distance = distance };
}
public IEnumerable<IFindResult> Find(IImage image)
{
var histogram = CalculateLineHistogram(image);
int threashold = (int)(0.95 * histogram.Max());
int startX = 0, endX = 0;
bool inSegment = false;
for (int x = 0; x < histogram.Length; x++)
{
if (histogram[x] < threashold && !inSegment)
{
inSegment = true;
startX = x;
}
if (histogram[x] >= threashold && inSegment)
{
endX = x - 1;
inSegment = false;
if (endX - startX > 3)
{
yield return new FindResult(startX, 0, image.Height - 1, endX - startX);
}
}
}
}
public static ProcessorResult CreateInput(IProcessor pro, IImage src)
{
ProcessorResult r = new ProcessorResult();
r.Result = src == null ? null : src.ToBitmap();
r.Name = "输入图像";
return r;
}
public void Analyze(System.Drawing.Bitmap bitmap, ColorConfig currentConfig, bool useMorphologic = true, bool detectBox = false)
{
System.Diagnostics.Stopwatch sw = System.Diagnostics.Stopwatch.StartNew();
bitmaps.UpdateImages(bitmap);
using (Image <Bgr, byte> img = new Image <Bgr, byte>(bitmaps.Bitmap))
{
IImage uimage = createMat();
CvInvoke.CvtColor(img.Clone(), uimage, ColorConversion.Bgr2Hsv, 3);
double cannyThreshold = 180.0;
double cannyThresholdLinking = 10.0;
IImage cannyEdges = createMat();
CvInvoke.Canny(img.Clone(), cannyEdges, cannyThreshold, cannyThresholdLinking);
if (detectBox)
{
var boxList = BoxDetection(cannyEdges);
foreach (var box in boxList)
{
for (int i = 0; i < box.Item1.Length; i++)
{
var pointA = box.Item1[i];
var pointB = box.Item1[(i + 1) % box.Item1.Length];
CvInvoke.Line(img, pointA, pointB, new Bgr(Color.DarkOrange).MCvScalar, 2);
}
}
}
//use image pyr to remove noise
IImage pyrDown = createMat();
CvInvoke.PyrDown(uimage, pyrDown);
CvInvoke.PyrUp(pyrDown, uimage);
IImage imgThresholded = createMat();
MCvScalar lower = new MCvScalar(currentConfig.LowH, currentConfig.LowS, currentConfig.LowV);
MCvScalar upper = new MCvScalar(currentConfig.HighH, currentConfig.HighS, currentConfig.HighV);
CvInvoke.InRange(uimage, new ScalarArray(lower), new ScalarArray(upper), imgThresholded);
if (useMorphologic)
{
morphOps(imgThresholded);
}
var contours = ContourDetection(imgThresholded);
var maxContour = contours.OrderByDescending(t => t.Item2).FirstOrDefault();
foreach (var box in contours)
{
MCvScalar contourColor;
if (box == maxContour)
{
contourColor = new Bgr(Color.DarkOrange).MCvScalar;
var vertices = box.Item4.GetVertices();
for (int i = 0; i < 4; i++)
{
CvInvoke.Line(img, new Point((int)vertices[i].X, (int)vertices[i].Y),
new Point((int)vertices[(i + 1) % 4].X, (int)vertices[(i + 1) % 4].Y), contourColor);
}
}
else
{
contourColor = new Bgr(Color.Green).MCvScalar;
}
for (int i = 0; i < box.Item1.Length; i++)
{
var pointA = box.Item1[i];
var pointB = box.Item1[(i + 1) % box.Item1.Length];
CvInvoke.Line(img, pointA, pointB, contourColor, 4);
}
CvInvoke.Circle(img, box.Item3, 5, contourColor, 2);
}
//Add Hour
CvInvoke.PutText(img, DateTime.Now.ToString(), new Point(5, 30), FontFace.HersheySimplex, 0.8, new Bgr(Color.LightBlue).MCvScalar);
bitmaps.Calculations = sw.ElapsedMilliseconds;
sw.Restart();
bitmaps.UpdateImages(null, img.ToBitmap(),
cannyEdges.Bitmap,
imgThresholded.Bitmap);
bitmaps.ImageSet = sw.ElapsedMilliseconds;
bitmaps.FPS = bitmaps.Calculations + bitmaps.ImageSet;
if (this.analyzerOutput != null)
{
analyzerOutput.FovSize = bitmaps.Bitmap.Size;
if (maxContour != null)
{
analyzerOutput.Detected = true;
analyzerOutput.Center = maxContour.Item3;
analyzerOutput.Width = (int)maxContour.Item4.Size.Width;
analyzerOutput.Height = (int)maxContour.Item4.Size.Height;
}
else
{
analyzerOutput.Detected = false;
analyzerOutput.Center = Point.Empty;
analyzerOutput.Distance = 0;
}
}
}
}
private void ExposePerson(GDMIndividualRecord iRec, string iName)
{
fWriter.BeginParagraph(TextAlignment.taLeft, 0, 0, 0, true);
fWriter.AddParagraphChunkAnchor(iName, fBoldFont, iRec.XRef);
fWriter.AddParagraphChunk(GKUtils.GetPedigreeLifeStr(iRec, PedigreeFormat.Compact), fTextFont);
fWriter.EndParagraph();
IImage image = fBase.Context.GetPrimaryBitmap(iRec, 0, 0, false);
fWriter.AddImage(image);
GDMIndividualRecord father, mother;
fBase.Context.Tree.GetParents(iRec, out father, out mother);
if (father != null)
{
fWriter.BeginParagraph(TextAlignment.taLeft, 0, 0, 0);
fWriter.AddParagraphChunk(LangMan.LS(LSID.LSID_Father) + ": ", fTextFont);
fWriter.AddParagraphChunkLink(GKUtils.GetNameString(father, true, false), fLinkFont, father.XRef);
fWriter.EndParagraph();
}
if (mother != null)
{
fWriter.BeginParagraph(TextAlignment.taLeft, 0, 0, 0);
fWriter.AddParagraphChunk(LangMan.LS(LSID.LSID_Mother) + ": ", fTextFont);
fWriter.AddParagraphChunkLink(GKUtils.GetNameString(mother, true, false), fLinkFont, mother.XRef);
fWriter.EndParagraph();
}
if (IncludeEvents && iRec.Events.Count != 0)
{
int num = iRec.Events.Count;
for (int i = 0; i < num; i++)
{
GDMCustomEvent evt = iRec.Events[i];
var evtType = evt.GetTagType();
if (evtType == GEDCOMTagType.BIRT || evtType == GEDCOMTagType.DEAT)
{
continue;
}
string evtName = GKUtils.GetEventName(evt);
string evtVal = evt.StringValue;
string evtDesc = GKUtils.GetEventDesc(fBase.Context.Tree, evt, false);
string tmp = evtName + ": " + evtVal;
if (evtVal != "")
{
tmp += ", ";
}
tmp += evtDesc;
fWriter.AddParagraph(tmp, fTextFont);
}
}
if (IncludeNotes && iRec.Notes.Count != 0)
{
int num = iRec.Notes.Count;
for (int i = 0; i < num; i++)
{
GDMLines noteLines = fTree.GetNoteLines(iRec.Notes[i]);
fWriter.AddParagraph(GKUtils.MergeStrings(noteLines), fTextFont);
}
}
}
public void DrawBackground(IImage image)
{
((IRendererExtended)Renderer).DrawBackground(image);
}
public void DrawImage(IImage image, float x, float y, float width, float height)
{
((IRendererExtended)Renderer).DrawImage(image, x, y, width, height);
}
public void DrawImage(IImage image, float x, float y)
{
((IRendererExtended)Renderer).DrawImage(image, x, y);
}
public static void DrawImage(this ICanvas canvas, IImage image, double x, double y, double width, double height, double alpha = 1.0)
{
canvas.DrawImage(image, new Rect(x, y, width, height), alpha);
}
public IImageView GetImageView(IImage image)
{
return(figmaDelegate.GetImageView(image));
}
public static void MapImageSource(IButtonHandler handler, IImage image)
{
}
public void BuildBy(GDMIndividualRecord iRec)
{
try {
fRec = iRec;
if (iRec != null)
{
if (fModel.PreparedIndividuals.IndexOf(iRec.XRef) < 0)
{
fModel.PreparedIndividuals.Add(iRec.XRef);
}
var parts = GKUtils.GetNameParts(iRec);
fSurname = parts.Surname;
fName = parts.Name;
fPatronymic = parts.Patronymic;
fNick = GKUtils.GetNickString(iRec);
fSex = iRec.Sex;
TreeChartOptions options = fModel.Options;
var lifeDates = iRec.GetLifeDates();
DateFormat dateFormat = (options.OnlyYears) ? DateFormat.dfYYYY : DateFormat.dfDD_MM_YYYY;
IsDead = (lifeDates.DeathEvent != null);
fBirthDate = GKUtils.GEDCOMEventToDateStr(lifeDates.BirthEvent, dateFormat, false);
fDeathDate = GKUtils.GEDCOMEventToDateStr(lifeDates.DeathEvent, dateFormat, false);
if (!options.OnlyYears)
{
if (options.ShowPlaces)
{
string birthPlace = GKUtils.GetPlaceStr(lifeDates.BirthEvent, false);
if (!string.IsNullOrEmpty(birthPlace))
{
if (!string.IsNullOrEmpty(fBirthDate))
{
fBirthDate += ", ";
}
fBirthDate += birthPlace;
}
string deathPlace = GKUtils.GetPlaceStr(lifeDates.DeathEvent, false);
if (!string.IsNullOrEmpty(deathPlace))
{
if (!string.IsNullOrEmpty(fDeathDate))
{
fDeathDate += ", ";
}
fDeathDate += deathPlace;
}
}
if (!string.IsNullOrEmpty(fBirthDate))
{
fBirthDate = ImportUtils.STD_BIRTH_SIGN + " " + fBirthDate;
}
if (!string.IsNullOrEmpty(fDeathDate))
{
fDeathDate = ImportUtils.STD_DEATH_SIGN + " " + fDeathDate;
}
}
if (options.SignsVisible)
{
EnumSet <SpecialUserRef> signs = EnumSet <SpecialUserRef> .Create();
int num = fRec.UserReferences.Count;
for (int i = 0; i < num; i++)
{
string rs = fRec.UserReferences[i].StringValue;
for (var cps = SpecialUserRef.urRI_StGeorgeCross; cps <= SpecialUserRef.urLast; cps++)
{
string sur = LangMan.LS(GKData.SpecialUserRefs[(int)cps].Title);
if (rs == sur)
{
signs.Include(cps);
}
}
}
fSigns = signs;
}
else
{
fSigns = EnumSet <SpecialUserRef> .Create();
}
if (options.PortraitsVisible)
{
try {
fPortrait = PortraitsCache.Instance.GetImage(fModel.Base.Context, iRec);
if (fPortrait == null && options.DefaultPortraits)
{
string resName = (fSex == GDMSex.svFemale) ? "pi_female_140.png" : "pi_male_140.png";
fPortrait = AppHost.GfxProvider.LoadResourceImage(resName, false);
}
} catch (MediaFileNotFoundException) {
if (!fModel.HasMediaFail)
{
AppHost.StdDialogs.ShowError(LangMan.LS(LSID.LSID_ArcNotFound));
fModel.HasMediaFail = true;
}
}
}
CertaintyAssessment = iRec.GetCertaintyAssessment();
}
else
{
fSurname = "";
fName = "< ? >";
fPatronymic = "";
fNick = "";
fBirthDate = "";
fDeathDate = "";
IsDead = false;
fSex = GDMSex.svUnknown;
fSigns = EnumSet <SpecialUserRef> .Create();
CertaintyAssessment = 0.0f;
}
} catch (Exception ex) {
Logger.LogWrite("TreeChartPerson.BuildBy(): " + ex.Message);
throw;
}
}
public ImageColumn(IImage <T> image, int column)
{
this.Parent = image;
this.column = column;
}
private void listenEvents()
{
socket.On(Socket.EVENT_CONNECT, () =>
{
connected = true;
});
socket.On(Socket.EVENT_DISCONNECT, () =>
{
disconnect();
});
socket.On("stop streaming", (data) =>
{
var map = Utils.GetMapFromData(data);
var stop = Convert.ToBoolean(map["stop"]);
if (stop)
{
btnLive.BackColor = Color.Gray;
}
});
socket.On("login", (data) =>
{
var map = Utils.GetMapFromData(data);
lblNumber.Text = Convert.ToInt32(map["numUsers"]).ToString() + " players";
var message = map["message"].ToString();
if (message == "success")
{
lbNotifications.Items.Add("You joined <3");
var reciever = new SocketIoAudioReceiver(socket);
player = new NetworkAudioPlayer(codec, reciever);
btnConnect.Text = "Disconnect";
enterName.Close();
btnChat.Enabled = true;
lblName.Text = "Player: " + user.Name;
}
else
{
lbNotifications.Items.Add(message);
}
});
socket.On("mc connected", (data) =>
{
var map = Utils.GetMapFromData(data);
game = Game.FromJson(map["game"].ToString());
lbNotifications.Items.Add(String.Format("😁 MC {0} joined", game.User.Name));
lblAward.Text = String.Format("$ {0}", game.Award);
});
socket.On("mc disconnected", (data) =>
{
var map = Utils.GetMapFromData(data);
var mc = User.FromJson(map["user"].ToString());
lbNotifications.Items.Add(String.Format("😂 MC {0} left", mc.Name));
});
socket.On("next question", (data) =>
{
lbNumberCorrectWrong.Text = "";
var map = Utils.GetMapFromData(data);
Question question = Question.FromJson(map["question"].ToString());
// speakQuestion(question);
loadQuestions(question);
int.TryParse(map["countDown"].ToString(), out seconds);
int numberQuestion;
int.TryParse(map["index"].ToString(), out numberQuestion);
numberQuestion++;
lblNumberQuestion.Text = "Question " + numberQuestion.ToString() + " ";
timerCountDown = new Thread(countDowner);
timerCountDown.Start();
showQuestion();
resetColorButtons();
enableButtons();
});
socket.On("continue players", (data) =>
{
var map = Utils.GetMapFromData(data);
int continuePlayers;
int stopsPlayers;
int.TryParse(map["continue"].ToString(), out continuePlayers);
int.TryParse(map["stop"].ToString(), out stopsPlayers);
lbNotifications.Items.Add(String.Format("Number of players continued: {0}", continuePlayers));
lbNotifications.Items.Add(String.Format("Number of players stopped: {0}", stopsPlayers));
});
socket.On("new game", (data) =>
{
lbCountDown.Text = "";
lblCorrect.Text = "";
lblNumberQuestion.Text = "";
lblQuestion.Text = "";
lbNumberCorrectWrong.Text = "";
user.NumberCorrect = 0;
hideQuestion();
});
socket.On("user joined", (data) =>
{
var map = Utils.GetMapFromData(data);
lblNumber.Text = Convert.ToInt32(map["numUsers"]).ToString() + " players";
var user = User.FromJson(map["user"].ToString());
lbNotifications.Items.Add(user.Name + " Joined");
});
socket.On("user left", (data) =>
{
var map = Utils.GetMapFromData(data);
lblNumber.Text = Convert.ToInt32(map["numUsers"]).ToString() + " players";
var user = User.FromJson(map["user"].ToString());
lbNotifications.Items.Add(user.Name + " left");
});
socket.On("correct answer", (data) =>
{
var map = Utils.GetMapFromData(data);
var correctAnswer = map["answer"].ToString();
disableButtons();
showCorrectAnswer(correctAnswer);
if (correctAnswer == answer.Id)
{
lblQuestion.Text = lblQuestion.Text + "\n👌 Yes! Right answer";
}
else
{
lblQuestion.Text = lblQuestion.Text + "\n😥 Nope! Wrong answer";
}
});
socket.On("new message", (data) =>
{
var map = Utils.GetMapFromData(data);
var message = MyMessage.FromJson(map["message"].ToString());
lbNotifications.Items.Add(message.UserName + ": " + message.Content);
});
socket.On("live video", (data) =>
{
var map = Utils.GetMapFromData(data);
imageLive = ImageLive.FromJson(map["image"].ToString());
if (imageLive != null && imageLive.Img1D != null)
{
btnLive.BackColor = Color.Red;
pLive.Refresh();
pLive.Image = IImage.ImageFromStream(imageLive.Img1D);
}
});
socket.On("tops", (data) =>
{
var map = Utils.GetMapFromData(data);
var tops = JsonConvert.DeserializeObject <List <User> >(map["tops"].ToString());
var question = Question.FromJson(map["question"].ToString());
int i = 1;
int numCorrectAll = 1;
int numWrongAll = 1;
int.TryParse(map["numberCorrect"].ToString(), out numCorrectAll);
int.TryParse(map["numberWrong"].ToString(), out numWrongAll);
lbNumberCorrectWrong.Text = String.Format("\nNumber correct: {0}\nNumber wrong: {1}", numCorrectAll, numWrongAll);
tops.ForEach((value) =>
{
var str = String.Format("Top {0}: {1} Correct {2}", i++, value.Name, value.NumberCorrect);
lbNotifications.Items.Add(str);
if (value.Name == user.Name)
{
user = value;
lblCorrect.Text = String.Format("Correct: {0}", user.NumberCorrect);
}
});
});
socket.On("congratulations", (data) =>
{
var map = Utils.GetMapFromData(data);
double bonus = 0;
double.TryParse(map["bonus"].ToString(), out bonus);
frmCongrats frmCongrats = new frmCongrats(user.Name, user.NumberCorrect, bonus);
frmCongrats.StartPosition = FormStartPosition.CenterParent;
frmCongrats.ShowDialog();
});
}
/// <summary>
/// Инициализация картинок для рамки сообщения
/// </summary>
/// <param name="bb">Нижняя полоса</param>
/// <param name="lb">Левый нижний угол</param>
/// <param name="ll">Левая полоса</param>
/// <param name="lt">Левый верхний угол</param>
/// <param name="rb">Правый нижний угол</param>
/// <param name="rr">Правая полоса</param>
/// <param name="rt">Правый верхний угол</param>
/// <param name="tt">Верхняя полоса</param>
/// <param name="button">Кнопка</param>
/// <param name="buttonPressed">Кнопка в нажатом состоянии</param>
public static void InitImages(IImage bb, IImage lb, IImage ll, IImage lt, IImage rb, IImage rr, IImage rt, IImage tt,
IImage button, IImage buttonPressed)
{
if (bb == null || lb == null || ll == null || lt == null || rb == null || rr == null || rt == null || tt == null ||
button == null || buttonPressed == null)
{
throw new ApplicationException("Message dialog images not initialized.");
}
dlg_BB = bb;
dlg_LB = lb;
dlg_LL = ll;
dlg_LT = lt;
dlg_RB = rb;
dlg_RR = rr;
dlg_RT = rt;
dlg_TT = tt;
dlg_button = button;
dlg_buttonPressed = buttonPressed;
}
/// <summary>
/// Convenience method to access WinForms <see cref="IImage"/> instance as WinForms <see cref="Bitmap"/>.
/// The returned <see cref="Bitmap"/> will be disposed when the <see cref="IImage"/> is disposed.
/// </summary>
/// <param name="image"><see cref="IImage"/> object.</param>
/// <returns><see cref="Bitmap"/> contents of <paramref name="image"/>.</returns>
public static Bitmap AsBitmap(this IImage image)
{
return(image.As <Bitmap>());
}
/// <summary>
/// Adds an image to an event.
/// </summary>
/// <param name="image">The list of images to add.</param>
/// <returns></returns>
public Task <IImage> CreateImageAsync(IImage image)
{
image.Id = Guid.NewGuid();
return(Repository.CreateImageAsync(image));
}
/// <summary>
/// Display the histograms of the specific image
/// </summary>
/// <param name="image">The image to retrieve histogram from</param>
public static void Show(IImage image)
{
Show(image, 256);
}
public GalleryController(IImage imageService)
{
_imageService = imageService;
}
internal void SetIcon(IImage pImage)
{
this.engine.DeleteImage(ref this.image);
this.image = pImage;
}
public void SetMessage(string message, bool highlighted, IImage icon)
{
statusBar.SetMessage(StringParser.Parse(message), highlighted);
}
public void SetTexture(IImage image)
{
Texture = image;
}
partial void beforeInitComponents(Resolver resolver, IImage image);
partial void afterInitComponents(Resolver resolver, IImage image);
public GaussianBlurEffectResource(IImage sourceImage)
: base(sourceImage)
{
this.StandardDeviation = 1f;
}
/// <summary>
/// Draws an image.
/// </summary>
/// <param name="source">The image.</param>
/// <param name="sourceRect">The rect in the image to draw.</param>
/// <param name="destRect">The rect in the output to draw to.</param>
/// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
public void DrawImage(IImage source, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = default)
{
Contract.Requires <ArgumentNullException>(source != null);
source.Draw(this, sourceRect, destRect, bitmapInterpolationMode);
}
/// <summary>
/// Draws an image.
/// </summary>
/// <param name="source">The image.</param>
/// <param name="sourceRect">The rect in the image to draw.</param>
/// <param name="destRect">The rect in the output to draw to.</param>
/// <param name="bitmapInterpolationMode">The bitmap interpolation mode.</param>
public void DrawImage(IImage source, Rect sourceRect, Rect destRect, BitmapInterpolationMode bitmapInterpolationMode = default)
{
_ = source ?? throw new ArgumentNullException(nameof(source));
source.Draw(this, sourceRect, destRect, bitmapInterpolationMode);
}
/// <summary>
/// Draws an image.
/// </summary>
/// <param name="source">The image.</param>
/// <param name="rect">The rect in the output to draw to.</param>
public void DrawImage(IImage source, Rect rect)
{
_ = source ?? throw new ArgumentNullException(nameof(source));
DrawImage(source, new Rect(source.Size), rect);
}
/// <summary>
/// Draws an image.
/// </summary>
/// <param name="source">The image.</param>
/// <param name="rect">The rect in the output to draw to.</param>
public void DrawImage(IImage source, Rect rect)
{
Contract.Requires <ArgumentNullException>(source != null);
DrawImage(source, new Rect(source.Size), rect);
}
public async Task <ILink> CreateLinkForUserAsync(ILink toBeCreatedLink, IGeneralUser user)
{
using (_dbContext)
{
var strategy = _dbContext.Database.CreateExecutionStrategy();
ILink ILink = default;
await strategy.Execute(async() =>
{
using (TransactionScope transaction = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
Link dbLink = _mapper.Map <ILink, Link>(toBeCreatedLink);
if (dbLink == default)
{
throw new ArgumentNullException(nameof(dbLink));
}
// Validate and save Interests
if (toBeCreatedLink.Interests != null)
{
foreach (IInterest iInterest in toBeCreatedLink.Interests)
{
Interest interest = _dbContext.Interests.SingleOrDefault(t => t.Id == iInterest.Id);
if (interest == default)
{
throw new ArgumentException($"Interest ID: {iInterest.Id} could not be found.");
}
LinkInterest newLinkInterest = new LinkInterest
{
InterestId = iInterest.Id
};
dbLink.LinkInterests.Add(newLinkInterest);
}
}
// Empty accidentally entered ImageWebUrl if uploadImageType is base64
if (dbLink.ImageType == UploadImageType.Base64 && dbLink.ImageWebUrl != null)
{
dbLink.ImageWebUrl = null;
}
// Set User
dbLink.GeneralUserId = user.Id;
// Prefix url
string[] httpPrefixes = { "http://", "https://" };
bool prefixMatch = httpPrefixes.Any(prefix => dbLink.Url.StartsWith(prefix));
if (!prefixMatch)
{
dbLink.Url = "https://" + dbLink.Url;
}
// Save
_dbContext.Links.Add(dbLink);
await _dbContext.SaveChangesAsync();
ILink = _mapper.Map <Link, ILink>(dbLink);
// save Image to AWS S3
if (toBeCreatedLink.ImageType == UploadImageType.Base64 && toBeCreatedLink.Image != null)
{
IImage linkImage = await _awsS3Service.UploadLinkImageAsync(toBeCreatedLink.Image, ILink);
ILink.Image = linkImage;
}
// Commit transaction if all commands succeed, transaction will auto-rollback
// when disposed if either commands fails
transaction.Complete();
}
});
return(ILink);
}
}
public static void DrawImage(this ICanvas canvas, IImage image)
{
canvas.DrawImage(image, new Rect(image.Size));
}
/// <summary>
/// Sets each image byte to zero (using kernel function memset).
/// </summary>
public static void Clear(this IImage image)
{
SetByte(image.ImageData, image.Width * image.ColorInfo.Size, image.Height, image.Stride, 0);
}
public void DrawImage(IImage image)
{
((IRendererExtended)Renderer).DrawImage(image);
}