public override RecyclerView.ViewHolder OnCreateViewHolder(ViewGroup parent, int viewType) { var width = (int)Math.Round(((Android.App.Activity)parent.Context).WindowManager.DefaultDisplay.Width - BitmapUtils.DpToPixel(25, parent.Resources)); var height = (int)Math.Round(BitmapUtils.DpToPixel(160, parent.Resources)); var previewSize = _gallery == null? ViewUtils.CalculateImagePreviewSize(_postMedia[0].Size.Width, _postMedia[0].Size.Height, width, height) : ViewUtils.CalculateImagePreviewSize(_gallery[0].PreparedBitmap.Width, _gallery[0].PreparedBitmap.Height, width, height); var cardView = new CardView(parent.Context) { LayoutParameters = new FrameLayout.LayoutParams(previewSize.Width, previewSize.Height), Radius = BitmapUtils.DpToPixel(5, parent.Resources) }; var image = new ImageView(parent.Context) { Id = Resource.Id.photo, LayoutParameters = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MatchParent, ViewGroup.LayoutParams.MatchParent) }; image.SetScaleType(ImageView.ScaleType.FitXy); cardView.AddView(image); return(new GalleryViewHolder(cardView)); }
public void DeletePixels(Layer[] layers, Coordinates[] pixels) { if (Manager.ActiveDocument == null) { return; } BitmapPixelChanges changes = BitmapPixelChanges.FromSingleColoredArray(pixels, Color.FromArgb(0, 0, 0, 0)); Dictionary <Guid, Color[]> oldValues = BitmapUtils.GetPixelsForSelection(layers, pixels); LayerChange[] old = new LayerChange[layers.Length]; LayerChange[] newChange = new LayerChange[layers.Length]; for (int i = 0; i < layers.Length; i++) { Guid guid = layers[i].LayerGuid; old[i] = new LayerChange( BitmapPixelChanges.FromArrays(pixels, oldValues[layers[i].LayerGuid]), guid); newChange[i] = new LayerChange(changes, guid); layers[i].SetPixels(changes); } Manager.ActiveDocument.UndoManager.AddUndoChange(new Change("UndoChanges", old, newChange, "Deleted pixels")); }
private void ImageChanged(object sender, EventArgs e) { SetImage(BitmapUtils.Bitmap2BitmapImage(_state.GetImage(0, 0).GetBitmap())); //Task.Factory.StartNew(()=>SetImage(BitmapUtils.Bitmap2BitmapImage(_state.GetImage(0,0).GetBitmap()))); }
public Bitmap Apply(Bitmap bitmap) { return(BitmapUtils.ResizeImage(bitmap, Size)); }
private static ImageSource LoadResource(string name) { return(BitmapUtils.FromResource($"Resources/FileIcons/{name}.png")); }
private async void strip_update(object sender, EventArgs e) { statusprogress.Visible = true; string penis = await currentcomic.source.fetchURL(stripretriever, ctk, date.Value); //String.Format(currentcomic.urlFormat, date.Value) Uri f**k; bool good = Uri.TryCreate(penis, UriKind.Absolute, out f**k); if (!good) { Uri.TryCreate(Path.GetFullPath(penis), UriKind.Absolute, out f**k); } //why in the world does absoluteuri return a string and not an uri /* * had to break my balls for this one. * none of the uri class methods don't even f*****g support * relative paths. */ Image img; if (f**k.IsFile) { string path = f**k.LocalPath; try{ FileStream fs = await Task.Run(() => File.OpenRead(path)); //File.OpenRead(path); its asynchronous now lol img = Image.FromStream(fs, false, false); } catch (FileNotFoundException suck) { img = BitmapUtils.drawMessage("not found"); } catch (IOException suck) { img = BitmapUtils.drawMessage("i/o exception.\nyour file must be locked.", 36); } } else { HttpResponseMessage response = new HttpResponseMessage(); try { //Stream stream = stripretriever.OpenRead(String.Format(currentcomic.urlFormat, date.Value)); //ctk.Cancel(); response = await currentcomic.source.fetch(penis, stripretriever, ctk); // response = await stripretriever.GetAsync(f**k, ctk.Token); response.EnsureSuccessStatusCode(); Stream stream = await response.Content.ReadAsStreamAsync(); img = Image.FromStream(stream, false, false); } catch (HttpRequestException suck) { //MessageBox.Show(suck.ToString()); img = BitmapUtils.drawMessage(((int)(response.StatusCode)).ToString()); } catch (ArgumentException suck) { img = BitmapUtils.drawMessage("an error occured while\nprocessing the image", 36); } } Bitmap bm = BitmapUtils.shittyCopy(img); // wish i could be using "using" here foreach (Gimmick gimmick in gimmicks.gimmicks) { if (gimmick.enabled) { img = gimmick.doIt(bm, img, currentcomic); bm = BitmapUtils.shittyCopy(img); // just found out Bitmap extends Image. what a waste // THis is prone to exceptions and im not doing anything abouti t } } bm.Dispose(); strip.Image = img; statusprogress.Visible = false; statusdate.Text = date.Value.ToString("d"); }
private static BaseBitmap ConvertGen3Bitmap(byte[] primaryData, byte[] secondaryData, BitmapTextureInteropDefinition definition, Bitmap bitmap, int imageIndex, bool isPaired, int pairIndex, BitmapTextureInteropDefinition otherDefinition, bool forDDS) { if (primaryData == null && secondaryData == null) { return(null); } using (var result = new MemoryStream()) { int mipLevelCount = definition.MipmapCount; int layerCount = definition.BitmapType == BitmapType.CubeMap ? 6 : definition.Depth; if (definition.BitmapType == BitmapType.Array && mipLevelCount > 1) { mipLevelCount = 1; definition.MipmapCount = 1; } if (!forDDS) { // order for d3d9, all faces first, then mipmaps for (int mipLevel = 0; mipLevel < mipLevelCount; mipLevel++) { for (int layerIndex = 0; layerIndex < layerCount; layerIndex++) { if (definition.BitmapType == BitmapType.CubeMap) // swap cubemap faces { if (layerIndex == 2) { layerIndex = 3; } else if (layerIndex == 3) { layerIndex = 2; } } ConvertGen3BitmapData(result, primaryData, secondaryData, definition, bitmap, imageIndex, mipLevel, layerIndex, isPaired, pairIndex, otherDefinition); if (definition.BitmapType == BitmapType.CubeMap) { if (layerIndex == 3) { layerIndex = 2; } else if (layerIndex == 2) { layerIndex = 3; } } } } } else { for (int layerIndex = 0; layerIndex < layerCount; layerIndex++) { if (definition.BitmapType == BitmapType.CubeMap) // swap cubemap faces { if (layerIndex == 2) { layerIndex = 3; } else if (layerIndex == 3) { layerIndex = 2; } } for (int mipLevel = 0; mipLevel < mipLevelCount; mipLevel++) { ConvertGen3BitmapData(result, primaryData, secondaryData, definition, bitmap, imageIndex, mipLevel, layerIndex, isPaired, pairIndex, otherDefinition); } if (definition.BitmapType == BitmapType.CubeMap) { if (layerIndex == 3) { layerIndex = 2; } else if (layerIndex == 2) { layerIndex = 3; } } } } var resultData = result.ToArray(); BaseBitmap resultBitmap = new BaseBitmap(bitmap.Images[imageIndex]); var newFormat = BitmapUtils.GetEquivalentBitmapFormat(bitmap.Images[imageIndex].Format); resultBitmap.UpdateFormat(newFormat); if (BitmapUtils.RequiresDecompression(resultBitmap.Format, (uint)resultBitmap.Width, (uint)resultBitmap.Height)) { resultBitmap.Format = BitmapFormat.A8R8G8B8; } if (!BitmapUtils.IsCompressedFormat(resultBitmap.Format)) { resultBitmap.Flags &= ~BitmapFlags.Compressed; } else { resultBitmap.Flags |= BitmapFlags.Compressed; } // // Update resource definition/image, truncate DXN to level 4x4 // resultBitmap.Data = resultData; if (resultBitmap.Format == BitmapFormat.Dxn) // wouldn't be required if d3d9 supported non power of two DXN and with mips less than 8x8 { GenerateCompressedMipMaps(resultBitmap); } if (resultBitmap.Type == BitmapType.Array) // for HO, arrays use the index of Texture3D { resultBitmap.Type = BitmapType.Texture3D; } return(resultBitmap); } }
private static void ConvertGen3BitmapData(Stream resultStream, byte[] primaryData, byte[] secondaryData, BitmapTextureInteropDefinition definition, Bitmap bitmap, int imageIndex, int level, int layerIndex, bool isPaired, int pairIndex, BitmapTextureInteropDefinition otherDefinition) { byte[] data; uint levelOffset; var d3dFormat = definition.D3DFormat; var isTiled = Direct3D.D3D9x.D3D.IsTiled(d3dFormat); uint blockWidth; uint blockHeight; uint alignedWidth = (uint)definition.Width >> level; uint alignedHeight = (uint)definition.Height >> level; if (alignedWidth < 1) { alignedWidth = 1; } if (alignedHeight < 1) { alignedHeight = 1; } uint alignedDepth = definition.Depth; var gpuFormat = XboxGraphics.XGGetGpuFormat(d3dFormat); uint bitsPerPixel = XboxGraphics.XGBitsPerPixelFromGpuFormat(gpuFormat); XboxGraphics.XGGetBlockDimensions(gpuFormat, out blockWidth, out blockHeight); XboxGraphics.XGPOINT point = new XboxGraphics.XGPOINT(); if (definition.MipmapCount > 1) { XboxGraphics.GetMipTailLevelOffsetCoords((uint)definition.Width, (uint)definition.Height, definition.Depth, (uint)level, gpuFormat, false, false, point); } var textureType = BitmapUtils.GetXboxBitmapD3DTextureType(definition); Direct3D.D3D9x.D3D.AlignTextureDimensions(ref alignedWidth, ref alignedHeight, ref alignedDepth, bitsPerPixel, gpuFormat, textureType, isTiled); if (level > 0) { // align to next power of two if (!Direct3D.D3D9x.D3D.IsPowerOfTwo((int)alignedWidth)) { alignedWidth = Direct3D.D3D9x.D3D.Log2Ceiling((int)alignedWidth); if (alignedWidth < 0) { alignedWidth = 0; } alignedWidth = 1u << (int)alignedWidth; } if (!Direct3D.D3D9x.D3D.IsPowerOfTwo((int)alignedHeight)) { alignedHeight = Direct3D.D3D9x.D3D.Log2Ceiling((int)alignedHeight); if (alignedHeight < 0) { alignedHeight = 0; } alignedHeight = 1u << (int)alignedHeight; } } // hacks when the point is outside of the first aligned texture, compute how many tiles you need and extract them (non-square only) if (point.X >= 32) { alignedWidth *= (uint)(1 + point.X / 32); } if (point.Y >= 32) { alignedHeight *= (uint)(1 + point.Y / 32); } uint texelPitch = blockWidth * blockHeight * bitsPerPixel / 8; uint size = alignedWidth * alignedHeight * bitsPerPixel / 8; // documentation says that each packed mip level should be aligned to 4KB, required to make untiling work smoothly size = (uint)((size + 0xFFF) & ~0xFFF); int tileOffset = 0; if (!isPaired) { bool useHighResBuffer = definition.HighResInSecondaryResource > 0; if ((level == 0 && useHighResBuffer) || primaryData == null) { levelOffset = BitmapUtils.GetXboxBitmapLevelOffset(definition, layerIndex, level); uint alignedSecondaryLength = (uint)((secondaryData.Length + 0x3FFF) & ~0x3FFF); data = new byte[alignedSecondaryLength]; Array.Copy(secondaryData, 0, data, 0, secondaryData.Length); } else { levelOffset = BitmapUtils.GetXboxBitmapLevelOffset(definition, layerIndex, level, useHighResBuffer); uint alignedPrimaryLength = (uint)((primaryData.Length + 0x3FFF) & ~0x3FFF); data = new byte[alignedPrimaryLength]; Array.Copy(primaryData, 0, data, 0, primaryData.Length); } } else { bool useHighResBuffer = definition.HighResInSecondaryResource > 0; var bitmap1 = pairIndex == 0 ? definition : otherDefinition; var bitmap2 = pairIndex == 0 ? otherDefinition : definition; if (level == 0 && useHighResBuffer) { levelOffset = BitmapUtils.GetXboxInterleavedBitmapOffset(bitmap1, bitmap2, layerIndex, level, pairIndex); uint alignedSecondaryLength = (uint)((secondaryData.Length + 0x3FFF) & ~0x3FFF); data = new byte[alignedSecondaryLength]; Array.Copy(secondaryData, 0, data, 0, secondaryData.Length); } else { levelOffset = BitmapUtils.GetXboxInterleavedBitmapOffset(bitmap1, bitmap2, layerIndex, level, pairIndex, useHighResBuffer); uint alignedPrimaryLength = (uint)((primaryData.Length + 0x3FFF) & ~0x3FFF); data = new byte[alignedPrimaryLength]; Array.Copy(primaryData, 0, data, 0, primaryData.Length); } } tileOffset += (int)levelOffset; byte[] tempResult = new byte[size]; // check if data has enough memory for the requested, size, sometimes it does not (truncated to save memory) uint copySize = size; if (size + tileOffset >= data.Length) { copySize = (uint)(data.Length - tileOffset); } Array.Copy(data, tileOffset, tempResult, 0, copySize); data = tempResult; uint nBlockWidth; uint nBlockHeight; if (isTiled) { // // Untile texture // byte[] result = new byte[size]; nBlockWidth = alignedWidth / blockWidth; nBlockHeight = alignedHeight / blockHeight; for (int i = 0; i < nBlockHeight; i++) { for (int j = 0; j < nBlockWidth; j++) { int destinationIndex = (int)(i * nBlockWidth + j); // offset in terms block int destinationOffset = (int)(destinationIndex * texelPitch); uint tiledIndex = XboxGraphics.XGAddress2DTiledOffset((uint)j, (uint)i, nBlockWidth, texelPitch); // returns offset in terms of block uint tiledOffset = tiledIndex * texelPitch; Array.Copy(data, tiledOffset, result, destinationOffset, texelPitch); } } data = result; } // find level size aligned to block size int levelWidth = definition.Width >> level; int levelHeight = definition.Height >> level; if (levelWidth < 1) { levelWidth = 1; } if (levelHeight < 1) { levelHeight = 1; } if (levelWidth % blockWidth != 0) { levelWidth = (int)(levelWidth + blockWidth - levelWidth % blockWidth); } if (levelHeight % blockHeight != 0) { levelHeight = (int)(levelHeight + blockHeight - levelHeight % blockHeight); } byte[] finalData = new byte[levelWidth * levelHeight * bitsPerPixel >> 3]; nBlockWidth = (uint)(levelWidth / blockWidth); nBlockHeight = (uint)(levelHeight / blockHeight); uint sliceBlockWidth = alignedWidth / blockWidth; // skip these loops if the bitmap is already the proper format if (point.X != 0 || point.Y != 0 || finalData.Length != data.Length) { for (int i = 0; i < nBlockHeight; i++) { for (int j = 0; j < nBlockWidth; j++) { uint offset = (uint)(((i + point.Y) * sliceBlockWidth) + j + point.X) * texelPitch; uint destOffset = (uint)((i * nBlockWidth) + j) * texelPitch; Array.Copy(data, offset, finalData, destOffset, texelPitch); } } } else { Array.Copy(data, 0, finalData, 0, data.Length); } XboxGraphics.XGEndianSwapSurface(d3dFormat, finalData); uint actualWidth = (uint)definition.Width >> level; uint actualHeight = (uint)definition.Height >> level; if (actualWidth < 1) { actualWidth = 1; } if (actualHeight < 1) { actualHeight = 1; } bool requireDecompression = BitmapUtils.RequiresDecompression(BitmapUtils.GetEquivalentBitmapFormat(bitmap.Images[imageIndex].Format), (uint)definition.Width, (uint)definition.Height); finalData = BitmapUtils.ConvertXboxFormats(finalData, actualWidth, actualHeight, bitmap.Images[imageIndex].Format, requireDecompression); resultStream.Write(finalData, 0, finalData.Length); }
protected Carto.Graphics.Bitmap CreateBitmap(string resource) { return(BitmapUtils.CreateBitmapFromUIImage(UIImage.FromFile(resource))); }
public static Carto.Graphics.Bitmap CreateBitmap(Context context, int resource) { return(BitmapUtils.CreateBitmapFromAndroidBitmap(Android.Graphics.BitmapFactory.DecodeResource(context.Resources, resource))); }
public void UpdateData(Post post, Context context) { Post = post; if (post.NetLikes > 0) { _likes.Visibility = ViewStates.Visible; _likes.Text = AppSettings.LocalizationManager.GetText(Post.NetLikes == 1 ? LocalizationKeys.Like : LocalizationKeys.Likes, post.NetLikes); } else { _likes.Visibility = ViewStates.Gone; } if (post.NetFlags > 0) { _flags.Visibility = _flagsIcon.Visibility = ViewStates.Visible; _flags.Text = $"{post.NetFlags}"; } else { _flags.Visibility = _flagsIcon.Visibility = ViewStates.Gone; } if (post.TotalPayoutReward > 0) { _cost.Visibility = ViewStates.Visible; _cost.Text = BasePresenter.ToFormatedCurrencyString(post.TotalPayoutReward); } else { _cost.Visibility = ViewStates.Gone; } _time.Text = post.Created.ToPostTime(); _author.Text = post.Author; if (!string.IsNullOrEmpty(Post.Avatar)) { Picasso.With(Context).Load(Post.Avatar).Placeholder(Resource.Drawable.ic_holder).Resize(300, 0).Priority(Picasso.Priority.Low).Into(_avatar, null, OnPicassoError); } else { Picasso.With(context).Load(Resource.Drawable.ic_holder).Into(_avatar); } ((PostPhotosPagerAdapter)_photosViewPager.Adapter).UpdateData(PhotoPagerType, Post); _topLikers.RemoveAllViews(); var topLikersSize = (int)BitmapUtils.DpToPixel(24, Context.Resources); var topLikersMargin = (int)BitmapUtils.DpToPixel(6, Context.Resources); for (int i = 0; i < Post.TopLikersAvatars.Length; i++) { var topLikersAvatar = new CircleImageView(Context) { BorderColor = Color.White, BorderWidth = 3, FillColor = Color.White }; var layoutParams = new LinearLayout.LayoutParams(topLikersSize, topLikersSize); if (i != 0) { layoutParams.LeftMargin = -topLikersMargin; } _topLikers.AddView(topLikersAvatar, layoutParams); var avatarUrl = Post.TopLikersAvatars[i]; if (!string.IsNullOrEmpty(avatarUrl)) { Picasso.With(Context).Load(avatarUrl).Placeholder(Resource.Drawable.ic_holder).Resize(240, 0).Priority(Picasso.Priority.Low).Into(topLikersAvatar, null, () => { Picasso.With(context).Load(Resource.Drawable.ic_holder).Into(topLikersAvatar); }); } else { Picasso.With(context).Load(Resource.Drawable.ic_holder).Into(topLikersAvatar); } } _title.UpdateText(Post, TagToExclude, TagFormat, MaxLines, Post.IsExpanded || PhotoPagerType == PostPagerType.PostScreen); _commentSubtitle.Text = post.Children == 0 ? AppSettings.LocalizationManager.GetText(LocalizationKeys.PostFirstComment) : post.Children == 1 ? AppSettings.LocalizationManager.GetText(LocalizationKeys.SeeComment) : AppSettings.LocalizationManager.GetText(LocalizationKeys.ViewComments, post.Children); if (_isAnimationRuning && !post.VoteChanging) { _isAnimationRuning = false; _likeOrFlag.ScaleX = 1f; _likeOrFlag.ScaleY = 1f; } if (!BasePostPresenter.IsEnableVote) { if (post.VoteChanging && !_isAnimationRuning) { LikeSet(false); } else if (post.FlagChanging) { LikeSet(true); } } else { if (post.Vote || !post.Flag) { _likeOrFlag.SetImageResource(post.Vote ? Resource.Drawable.ic_new_like_filled : Resource.Drawable.ic_new_like_selected); } else { _likeOrFlag.SetImageResource(Resource.Drawable.ic_flag_active); } } _pagerTabLayout.Visibility = post.Media.Length > 1 ? ViewStates.Visible : ViewStates.Gone; SetNsfwMaskLayout(); if (Post.Flag && !Post.FlagNotificationWasShown) { NsfwMask.Visibility = ViewStates.Visible; _nsfwMaskCloseButton.Visibility = ViewStates.Visible; _nsfwMaskMessage.Text = AppSettings.LocalizationManager.GetText(LocalizationKeys.FlagMessage); NsfwMaskSubMessage.Text = AppSettings.LocalizationManager.GetText(LocalizationKeys.FlagSubMessage); _nsfwMaskActionButton.Text = AppSettings.LocalizationManager.GetText(LocalizationKeys.UnFlagPost); } else if (Post.ShowMask && (Post.IsLowRated || Post.IsNsfw)) { NsfwMask.Visibility = ViewStates.Visible; _nsfwMaskMessage.Text = AppSettings.LocalizationManager.GetText(Post.IsLowRated ? LocalizationKeys.LowRatedContent : LocalizationKeys.NsfwContent); NsfwMaskSubMessage.Text = AppSettings.LocalizationManager.GetText(Post.IsLowRated ? LocalizationKeys.LowRatedContentExplanation : LocalizationKeys.NsfwContentExplanation); _nsfwMaskActionButton.Text = AppSettings.LocalizationManager.GetText(LocalizationKeys.NsfwShow); } else { NsfwMask.Visibility = _nsfwMaskCloseButton.Visibility = ViewStates.Gone; } }
public override void ViewDidLoad() { base.ViewDidLoad(); AddOnlineBaseLayer(CartoBaseMapStyle.CartoBasemapStyleGray); Projection projection = BaseProjection; // Initialize an local vector data source LocalVectorDataSource source = new LocalVectorDataSource(projection); // Initialize a vector layer with the previous data source VectorLayer vectorLayer = new VectorLayer(source); // Add the previous vector layer to the map MapView.Layers.Add(vectorLayer); // Set visible zoom range for the vector layer vectorLayer.VisibleZoomRange = new MapRange(10, 24); // Add a bunch of vector elements // As elements can be shared across platforms, they are in a shared project Overlays.AddPoint1(source, projection); Overlays.AddPoint2(source, projection); Overlays.AddOverlyingLines(MapView, source, projection); Overlays.Add2DPolygon(source, projection); Overlays.AddText1(source, projection); Overlays.AddText2(source, projection); Overlays.AddText3(source, projection); Bitmap info = BitmapUtils.CreateBitmapFromUIImage(UIImage.FromFile("icons/info.png")); Bitmap arrow = BitmapUtils.CreateBitmapFromUIImage(UIImage.FromFile("icons/arrow.png")); Bitmap marker = BitmapUtils.CreateBitmapFromUIImage(UIImage.FromFile("icons/marker.png")); Overlays.AddBalloonPopup1(source, projection, info, arrow); Overlays.AddBalloonPopup2(source, projection, info, arrow, marker); Overlays.AddBalloonPopup3(source, projection); Overlays.Add3DCar(source, projection); Overlays.Add3DPolygon(source, projection); // Animate map to Tallinn where the objects are MapView.SetFocusPos(projection.FromWgs84(new MapPos(24.662893, 59.419365)), 1); MapView.SetZoom(12, 1); // Add maplistener to detect click on model listener = new VectorElementListener(source); for (int i = 0; i < MapView.Layers.Count; i++) { Layer layer = MapView.Layers[i]; if (layer is VectorLayer) { (layer as VectorLayer).VectorElementEventListener = listener; } } }
private void SetProfileChart(int size) { var votingPowerFrame = new VotingPowerFrame(this) { Draw = true, VotingPower = Presenter.UserProfileResponse == null ? 0 : (float)Presenter.UserProfileResponse.VotingPower, VotingPowerWidth = BitmapUtils.DpToPixel(3, Resources) }; var padding = (int)BitmapUtils.DpToPixel(7, Resources); votingPowerFrame.Layout(0, 0, size, size); var avatar = new CircleImageView(this); avatar.Layout(padding, padding, size - padding, size - padding); avatar.SetImageResource(Resource.Drawable.ic_holder); votingPowerFrame.AddView(avatar); var profileTab = _tabLayout.GetTabAt(_tabLayout.TabCount - 1); if (!string.IsNullOrEmpty(Presenter.UserProfileResponse?.ProfileImage)) { Picasso.With(this).Load(Presenter.UserProfileResponse.ProfileImage).NoFade().Resize(size, size) .Placeholder(Resource.Drawable.ic_holder).Into(avatar, () => { profileTab.SetIcon(BitmapUtils.GetViewDrawable(votingPowerFrame)); }, null); } else { profileTab.SetIcon(BitmapUtils.GetViewDrawable(votingPowerFrame)); } }
/// <summary> /// Returns a byte[] containing the converted image data from the cache. /// </summary> /// <param name="cache"></param> /// <param name="bitmapTag"></param> /// <param name="index"></param> /// <param name="version"></param> /// <returns></returns> public static BaseBitmap ConvertGen3Bitmap(CacheFile cache, Bitmap bitmapTag, int index, CacheVersion version) { if (cache.ResourceLayoutTable == null || cache.ResourceGestalt == null) { cache.LoadResourceTags(); } byte[] imageData = null; byte[] mipMapData = null; XboxBitmap xboxBitmap = null; int bitmapSize = 0; int mipMapSize = 0; var image = bitmapTag.Images[index]; var handle = GetBitmapResourceHandle(bitmapTag, index, version); if (!ResourceEntryValid(cache, handle) || (!HasPrimaryResource(cache, handle) && !HasSecondaryResource(cache, handle))) { Console.WriteLine($"Invalid resource entry at {handle}. No data to convert."); return(null); } // interleaved means two images are inside a single resource along with the mipmaps. if (image.XboxFlags.HasFlag(BitmapFlagsXbox.UseInterleavedTextures)) { var resourceDef = GetInterleavedResourceDefinition(cache, handle); xboxBitmap = new XboxBitmap(resourceDef, image.InterleavedTextureIndex2, image); bitmapSize = BitmapUtils.GetXboxImageSize(xboxBitmap); mipMapSize = 0; xboxBitmap.Offset = 0; if (!xboxBitmap.InTile) { var offset = image.InterleavedTextureIndex2 * (int)(xboxBitmap.VirtualHeight * xboxBitmap.VirtualWidth / xboxBitmap.CompressionFactor); imageData = cache.GetSecondaryResource(handle, bitmapSize, offset, true); mipMapData = null; } else { if (xboxBitmap.Type == BitmapType.CubeMap && image.Flags.HasFlag(BitmapFlags.Compressed) && xboxBitmap.Width <= 16) { xboxBitmap.Offset = (int)(16 * 4 / xboxBitmap.CompressionFactor); // account for the mipmaps } imageData = cache.GetPrimaryResource(handle, bitmapSize, 0, true); mipMapData = null; } if (image.InterleavedTextureIndex2 == 1 && xboxBitmap.InTile) { byte[] totalData = null; var tileSize = (int)(xboxBitmap.MinimalBitmapSize * xboxBitmap.MinimalBitmapSize / xboxBitmap.CompressionFactor); var subCount = 0; switch (xboxBitmap.Type) { case BitmapType.Texture2D: subCount = 1; break; case BitmapType.Texture3D: case BitmapType.Array: subCount = xboxBitmap.Depth; break; case BitmapType.CubeMap: subCount = 6; break; } if (mipMapData != null) { totalData = new byte[bitmapSize + mipMapSize]; Array.Copy(imageData, 0, totalData, 0, bitmapSize); Array.Copy(mipMapData, 0, totalData, bitmapSize, mipMapSize); } else { totalData = imageData; } for (int i = 0; i < subCount; i++) { // make sure to copy the right amount of data var copySize = tileSize; if (copySize > totalData.Length - ((tileSize * i) + tileSize / 2)) { copySize = totalData.Length - ((tileSize * i) + tileSize / 2); } Array.Copy(totalData, (tileSize * i) + tileSize / 2, imageData, (tileSize * i), copySize); } } } else { var resourceDef = GetResourceDefinition(cache, handle); xboxBitmap = new XboxBitmap(resourceDef, image); bitmapSize = BitmapUtils.GetXboxImageSize(xboxBitmap); if (HasSecondaryResource(cache, handle)) { imageData = cache.GetSecondaryResource(handle, bitmapSize, 0, true); if (xboxBitmap.MipMapCount > 0) { if (HasPrimaryResource(cache, handle)) { // dedicated resource for mipmaps mipMapData = cache.GetPrimaryResource(handle, mipMapSize, 0, true); } else { //throw new Exception($"Unsupported layout. Compute bitmap offset for weird bitmap."); mipMapData = null; } } else { mipMapData = null; } } else { // Bitmap doesn't have a secondary resource means either no mipmaps or everything is packed in the primary resource. if (xboxBitmap.MipMapCount > 0) { imageData = cache.GetPrimaryResource(handle, 2 * bitmapSize, 0, true); mipMapData = cache.GetPrimaryResource(handle, mipMapSize, 0, true); // Formula seems quite complex, small hack to make it work if (xboxBitmap.BlockDimension == 4) { if (xboxBitmap.Width > xboxBitmap.Height) { xboxBitmap.Offset = 4 * (int)(BitmapUtils.RoundSize(xboxBitmap.Height, 4) * xboxBitmap.VirtualWidth / xboxBitmap.CompressionFactor); } else if (xboxBitmap.Width == xboxBitmap.Height) { var width = xboxBitmap.Width; if (xboxBitmap.Width >= 4) { width = 4; } xboxBitmap.Offset = 4 * (int)(width * 4 / xboxBitmap.CompressionFactor); } else { var width = xboxBitmap.Width / 2; if (width == 0) { width = 1; } xboxBitmap.Offset = 4 * (int)(BitmapUtils.RoundSize(width, 4) * xboxBitmap.BlockDimension / xboxBitmap.CompressionFactor); } } else { xboxBitmap.Offset = (int)(xboxBitmap.Width * 4 / xboxBitmap.CompressionFactor); Console.WriteLine("WEIRD BITMAP"); } } else { imageData = cache.GetPrimaryResource(handle, bitmapSize, 0, true); mipMapData = null; } } } // // Convert main bitmap // List <XboxBitmap> xboxBitmaps = ParseImages(xboxBitmap, image, imageData, bitmapSize); bool flipImage = true; // rearrange cubemaps order if (xboxBitmap.Type == BitmapType.CubeMap) { XboxBitmap temp = xboxBitmaps[1]; xboxBitmaps[1] = xboxBitmaps[2]; xboxBitmaps[2] = temp; } List <BaseBitmap> finalBitmaps = new List <BaseBitmap>(); foreach (var bitmap in xboxBitmaps) { // extract bitmap from padded image BaseBitmap finalBitmap = ExtractImage(bitmap); // convert to PC format flipImage = ConvertImage(finalBitmap); // flip data if required if (flipImage) { FlipImage(finalBitmap, image); } // until I write code to move mipmaps at the end of the file, remove cubemap mipmaps if (xboxBitmap.Type == BitmapType.CubeMap) { finalBitmap.MipMapCount = 0; } // generate mipmaps for uncompressed textures if (!finalBitmap.Flags.HasFlag(BitmapFlags.Compressed) && finalBitmap.MipMapCount > 0) { GenerateUncompressedMipMaps(finalBitmap); } finalBitmaps.Add(finalBitmap); } // build and return the final bitmap return(RebuildBitmap(finalBitmaps)); }
public override void OnViewCreated(View view, Bundle savedInstanceState) { if (!IsInitialized) { base.OnViewCreated(view, savedInstanceState); Presenter.SourceChanged += PresenterSourceChanged; _adapter = new FeedAdapter <FeedPresenter>(Context, Presenter); _adapter.LikeAction += LikeAction; _adapter.UserAction += UserAction; _adapter.CommentAction += CommentAction; _adapter.VotersClick += VotersAction; _adapter.PhotoClick += FeedPhotoClick; _adapter.FlagAction += FlagAction; _adapter.HideAction += HideAction; _adapter.TagAction += TagAction; _postPagerAdapter = new PostPagerAdapter <FeedPresenter>(Context, Presenter); _postPagerAdapter.LikeAction += LikeAction; _postPagerAdapter.UserAction += UserAction; _postPagerAdapter.CommentAction += CommentAction; _postPagerAdapter.VotersClick += VotersAction; _postPagerAdapter.PhotoClick += PhotoClick; _postPagerAdapter.FlagAction += FlagAction; _postPagerAdapter.HideAction += HideAction; _postPagerAdapter.DeleteAction += DeleteAction; _postPagerAdapter.TagAction += TagAction; _postPagerAdapter.CloseAction += CloseAction; _logo.Click += OnLogoClick; _toolbar.OffsetChanged += OnToolbarOffsetChanged; _scrollListner = new ScrollListener(); _scrollListner.ScrolledToBottom += LoadPosts; _refresher.Refresh += OnRefresh; _feedList.SetAdapter(_adapter); _feedList.SetLayoutManager(new LinearLayoutManager(Android.App.Application.Context)); _feedList.AddOnScrollListener(_scrollListner); _postPager.SetClipToPadding(false); var pagePadding = (int)BitmapUtils.DpToPixel(20, Resources); _postPager.SetPadding(pagePadding, 0, pagePadding, 0); _postPager.PageMargin = pagePadding / 2; _postPager.PageScrollStateChanged += PostPagerOnPageScrollStateChanged; _postPager.PageScrolled += PostPagerOnPageScrolled; _postPager.Adapter = _postPagerAdapter; _postPager.SetPageTransformer(false, _postPagerAdapter, (int)LayerType.None); _emptyQueryLabel.Typeface = Style.Light; _emptyQueryLabel.Text = Localization.Texts.EmptyQuery; LoadPosts(); } var postUrl = Activity?.Intent?.GetStringExtra(CommentsFragment.ResultString); if (!string.IsNullOrWhiteSpace(postUrl)) { var count = Activity.Intent.GetIntExtra(CommentsFragment.CountString, 0); Activity.Intent.RemoveExtra(CommentsFragment.ResultString); Activity.Intent.RemoveExtra(CommentsFragment.CountString); var post = Presenter.FirstOrDefault(p => p.Url == postUrl); post.Children += count; _adapter.NotifyDataSetChanged(); } }
protected void RunFile(bool runTestsViewOut, string pspAutoTestsFolder, string fileNameExecutable, string fileNameExpected, string fileNameBase) { ConsoleUtils.SaveRestoreConsoleColor(ConsoleColor.DarkCyan, () => { Console.Write("{0}...", fileNameExecutable); }); var expectedOutput = File.ReadAllText(fileNameExpected, Encoding.ASCII); var realOutput = ""; var capturedOutput = ""; // Execute. { realOutput = RunExecutableAndGetOutput(runTestsViewOut, pspAutoTestsFolder, fileNameExecutable, out capturedOutput, fileNameBase); } var expectedOutputLines = expectedOutput.Trim().Replace("\r\n", "\n").Split('\n'); var realOutputLines = realOutput.Trim().Replace("\r\n", "\n").Split('\n'); var result = Diff.DiffTextProcessed(expectedOutputLines, realOutputLines); File.WriteAllText( Path.ChangeExtension(fileNameExpected, ".lastoutput"), realOutput ); File.WriteAllText( Path.ChangeExtension(fileNameExpected, ".lastdebug"), capturedOutput ); var hadAnError = false; for (var n = 0; n < 10; n++) { var imageReferenceFile = $"{fileNameBase}.reference.{n}.png"; var imageOutputFile = $"{fileNameBase}.lastoutput.{n}.png"; if (File.Exists(imageReferenceFile)) { if (File.Exists(imageOutputFile)) { var referenceBitmap = new Bitmap(imageReferenceFile); var outputBitmap = new Bitmap(imageOutputFile); if (referenceBitmap.Size == outputBitmap.Size) { var compareResult = BitmapUtils.CompareBitmaps(referenceBitmap, outputBitmap, 0.01); if (compareResult.Equal) { Console.Error.WriteLine( "Files '{0}:{1}' and '{2}:{3}' have different contents {4}/{5} different pixels {6}%", imageReferenceFile, referenceBitmap.Size, imageOutputFile, outputBitmap.Size, compareResult.DifferentPixelCount, compareResult.TotalPixelCount, compareResult.PixelTotalDifferencePercentage ); hadAnError = true; } } else { Console.Error.WriteLine( "Files '{0}:{1}' and '{2}:{3}' have different sizes", imageReferenceFile, referenceBitmap.Size, imageOutputFile, outputBitmap.Size ); hadAnError = true; } } else { Console.Error.WriteLine( "File '{0}' exists, but not exists '{1}'", imageReferenceFile, imageOutputFile ); hadAnError = true; } } } if (result.Items.Any(item => item.Action != Diff.ProcessedItem.ActionEnum.Keep)) { hadAnError = true; } if (!hadAnError) { ConsoleUtils.SaveRestoreConsoleColor(ConsoleColor.Green, () => { Console.WriteLine("Ok"); }); } else { ConsoleUtils.SaveRestoreConsoleColor(ConsoleColor.Red, () => { Console.WriteLine("Error"); }); result.Print(avoidKeep: true); } File.WriteAllText( Path.ChangeExtension(fileNameExpected, ".lastdiff"), result.ToString() ); }
public Bitmap Apply(Bitmap bitmap) { return(BitmapUtils.Corrode(bitmap)); }
protected Carto.Graphics.Bitmap CreateBitmap(int resource) { return(BitmapUtils.CreateBitmapFromAndroidBitmap(Android.Graphics.BitmapFactory.DecodeResource(Resources, resource))); }
protected override void OnCreate(Android.OS.Bundle savedInstanceState) { base.OnCreate(savedInstanceState); /// Set online base layer var baseLayer = new NutiteqOnlineVectorTileLayer("nutibright-v2a.zip"); mapView.Layers.Add(baseLayer); // create PackageManager instance for dealing with offline packages var packageFolder = new File(GetExternalFilesDir(null), "routingpackages"); if (!(packageFolder.Mkdirs() || packageFolder.IsDirectory)) { Log.Fatal("Could not create package folder!"); } packageManager = new NutiteqPackageManager(ROUTING_PACKAGEMANAGER_SOURCE, packageFolder.AbsolutePath); packageManager.PackageManagerListener = new RoutingPackageListener(this); packageManager.Start(); // fetch list of available packages from server. Note that this is asynchronous operation and listener will be notified via onPackageListUpdated when this succeeds. packageManager.StartPackageListDownload(); // create offline routing service connected to package manager offlineRoutingService = new PackageManagerRoutingService(packageManager); // create additional online routing service that will be used when offline package is not yet downloaded or offline routing fails onlineRoutingService = new NutiteqOnlineRoutingService(ROUTING_SERVICE_SOURCE); // define layer and datasource for route line and instructions routeDataSource = new LocalVectorDataSource(baseProjection); VectorLayer routeLayer = new VectorLayer(routeDataSource); mapView.Layers.Add(routeLayer); // define layer and datasource for route start and stop markers routeStartStopDataSource = new LocalVectorDataSource(baseProjection); // Initialize a vector layer with the previous data source VectorLayer vectorLayer = new VectorLayer(routeStartStopDataSource); // Add the previous vector layer to the map mapView.Layers.Add(vectorLayer); // Set visible zoom range for the vector layer vectorLayer.VisibleZoomRange = new MapRange(0, 22); // set route listener RouteMapEventListener mapListener = new RouteMapEventListener(this); mapView.MapEventListener = mapListener; // create markers for start & end, and a layer for them MarkerStyleBuilder markerStyleBuilder = new MarkerStyleBuilder(); markerStyleBuilder.Bitmap = BitmapUtils .CreateBitmapFromAndroidBitmap(BitmapFactory.DecodeResource( Resources, Resource.Drawable.olmarker)); markerStyleBuilder.HideIfOverlapped = false; markerStyleBuilder.Size = 30; markerStyleBuilder.Color = new Nutiteq.Graphics.Color(Android.Graphics.Color.Green); startMarker = new Marker(new MapPos(0, 0), markerStyleBuilder.BuildStyle()); startMarker.Visible = false; markerStyleBuilder.Color = new Nutiteq.Graphics.Color(Android.Graphics.Color.Red); stopMarker = new Marker(new MapPos(0, 0), markerStyleBuilder.BuildStyle()); stopMarker.Visible = false; routeStartStopDataSource.Add(startMarker); routeStartStopDataSource.Add(stopMarker); markerStyleBuilder.Color = new Nutiteq.Graphics.Color(Android.Graphics.Color.White); markerStyleBuilder.Bitmap = BitmapUtils .CreateBitmapFromAndroidBitmap(BitmapFactory.DecodeResource( Resources, Resource.Drawable.direction_up)); instructionUp = markerStyleBuilder.BuildStyle(); markerStyleBuilder.Bitmap = BitmapUtils .CreateBitmapFromAndroidBitmap(BitmapFactory.DecodeResource( Resources, Resource.Drawable.direction_upthenleft)); instructionLeft = markerStyleBuilder.BuildStyle(); markerStyleBuilder.Bitmap = BitmapUtils .CreateBitmapFromAndroidBitmap(BitmapFactory.DecodeResource( Resources, Resource.Drawable.direction_upthenright)); instructionRight = markerStyleBuilder.BuildStyle(); // style for instruction balloons balloonPopupStyleBuilder = new BalloonPopupStyleBuilder(); balloonPopupStyleBuilder.TitleMargins = new BalloonPopupMargins(4, 4, 4, 4); // finally animate map to Estonia mapView.FocusPos = baseProjection.FromWgs84(new MapPos(25.662893, 58.919365)); mapView.Zoom = 7; Toast.MakeText(ApplicationContext, "Long-press on map to set route start and finish", ToastLength.Long).Show(); }
public override void OnViewCreated(View view, Bundle savedInstanceState) { if (IsInitialized) { return; } base.OnViewCreated(view, savedInstanceState); _tag.Hint = AppSettings.LocalizationManager.GetText(LocalizationKeys.AddHashtag); _title.Hint = AppSettings.LocalizationManager.GetText(LocalizationKeys.EnterPostTitle); _description.Hint = AppSettings.LocalizationManager.GetText(LocalizationKeys.EnterPostDescription); _postButton.Text = AppSettings.LocalizationManager.GetText(LocalizationKeys.PublishButtonText); _pageTitle.Text = AppSettings.LocalizationManager.GetText(LocalizationKeys.PostSettings); _pageTitle.Typeface = Style.Semibold; _title.Typeface = Style.Regular; _description.Typeface = Style.Regular; _postButton.Typeface = Style.Semibold; _postButton.Click += OnPost; _postButton.Enabled = true; _topPanel.BringToFront(); _localTagsList.SetLayoutManager(new LinearLayoutManager(Activity, LinearLayoutManager.Horizontal, false)); LocalTagsAdapter.Click += LocalTagsAdapterClick; _localTagsList.SetAdapter(LocalTagsAdapter); _localTagsList.AddItemDecoration(new ListItemDecoration((int)TypedValue.ApplyDimension(ComplexUnitType.Dip, 15, Resources.DisplayMetrics))); _tagsList.SetLayoutManager(new LinearLayoutManager(Activity)); Presenter.SourceChanged += PresenterSourceChanged; TagsAdapter.Click += OnTagsAdapterClick; _tagsList.SetAdapter(TagsAdapter); _tag.TextChanged += OnTagOnTextChanged; _tag.KeyboardDownEvent += HideTagsList; _tag.OkKeyEvent += HideTagsList; _tag.FocusChange += OnTagOnFocusChange; _topMarginTagsLayout.Click += OnTagsLayoutClick; _backButton.Click += OnBack; _rootLayout.Click += OnRootLayoutClick; _timer = new Timer(OnTimer); _model = new PreparePostModel(BasePresenter.User.UserInfo); SetPostingTimer(); if (_editPost != null) { SetEditPost(); } if (_media?.Count > 1 || _editPost?.Media.Length > 1) { _photos.Visibility = ViewStates.Visible; _previewContainer.Visibility = ViewStates.Gone; _photos.SetLayoutManager(new LinearLayoutManager(Activity, LinearLayoutManager.Horizontal, false)); _photos.SetAdapter(GalleryAdapter); _photos.AddItemDecoration(new ListItemDecoration((int)TypedValue.ApplyDimension(ComplexUnitType.Dip, 10, Resources.DisplayMetrics))); } else { _photos.Visibility = ViewStates.Gone; _previewContainer.Visibility = ViewStates.Visible; var margin = (int)BitmapUtils.DpToPixel(15, Resources); var layoutParams = new RelativeLayout.LayoutParams(Resources.DisplayMetrics.WidthPixels - margin * 2, Resources.DisplayMetrics.WidthPixels - margin * 2); layoutParams.SetMargins(margin, 0, margin, margin); _previewContainer.LayoutParameters = layoutParams; _preview.CornerRadius = BitmapUtils.DpToPixel(5, Resources); if (_media != null) { _preview.SetImageUri(Uri.Parse(_media[0].Path), _media[0].Parameters); } else if (_editPost != null) { _ratioBtn.Visibility = _rotateBtn.Visibility = ViewStates.Gone; var url = _editPost.Media[0].Thumbnails.Mini; Picasso.With(Activity).Load(url) .Resize(_previewContainer.LayoutParameters.Width, _previewContainer.LayoutParameters.Height) .Into(_preview); } _preview.Touch += PreviewOnTouch; _ratioBtn.Click += RatioBtnOnClick; _rotateBtn.Click += RotateBtnOnClick; } SearchTextChanged(); }
private static void GenerateCompressedMipMaps(BaseBitmap bitmap) { string tempBitmap = $@"Temp\{Guid.NewGuid().ToString()}.dds"; if (!Directory.Exists(@"Temp")) { Directory.CreateDirectory(@"Temp"); } //Write input dds bitmap.MipMapCount = 0; var header = new DDSHeader(bitmap); using (var outStream = File.Open(tempBitmap, FileMode.Create, FileAccess.Write)) { header.Write(new EndianWriter(outStream)); var dataStream = new MemoryStream(bitmap.Data); StreamUtil.Copy(dataStream, outStream, bitmap.Data.Length); } string args = " "; switch (bitmap.Format) { case BitmapFormat.Dxn: args += "-bc5 -resize -normal"; break; case BitmapFormat.Dxt1: args += "-bc1 "; break; case BitmapFormat.Dxt3: args += "-bc2 "; break; case BitmapFormat.Dxt5: args += "-bc3 "; break; default: bitmap.MipMapCount = 0; if (File.Exists(tempBitmap)) { File.Delete(tempBitmap); } return; } args += $"{tempBitmap} {tempBitmap}"; ProcessStartInfo info = new ProcessStartInfo(@"Tools\nvcompress.exe") { Arguments = args, CreateNoWindow = true, WindowStyle = ProcessWindowStyle.Hidden, UseShellExecute = false, RedirectStandardError = false, RedirectStandardOutput = false, RedirectStandardInput = false }; Process nvcompress = Process.Start(info); nvcompress.WaitForExit(); byte[] result; using (var ddsStream = File.OpenRead(tempBitmap)) { header.Read(new EndianReader(ddsStream)); var dataSize = (int)(ddsStream.Length - ddsStream.Position); int mipMapCount = header.MipMapCount - 1; bitmap.Width = header.Width; bitmap.Height = header.Height; // Remove lowest DXN mipmaps to prevent issues with D3D memory allocation. if (bitmap.Format == BitmapFormat.Dxn) { dataSize = BitmapUtils.RoundSize(bitmap.Width, 4) * BitmapUtils.RoundSize(bitmap.Height, 4); if (mipMapCount > 0) { if (bitmap.Format == BitmapFormat.Dxn) { var width = bitmap.Width; var height = bitmap.Height; dataSize = BitmapUtils.RoundSize(width, 4) * BitmapUtils.RoundSize(height, 4); mipMapCount = 0; while ((width >= 8) && (height >= 8)) { width /= 2; height /= 2; dataSize += BitmapUtils.RoundSize(width, 4) * BitmapUtils.RoundSize(height, 4); mipMapCount++; } } } } bitmap.MipMapCount = mipMapCount; byte[] raw = new byte[dataSize]; ddsStream.Read(raw, 0, dataSize); result = raw; bitmap.Data = result; } if (File.Exists(tempBitmap)) { File.Delete(tempBitmap); } }
private void OnToolbarOffsetChanged(object sender, AppBarLayout.OffsetChangedEventArgs e) { ViewCompat.SetElevation(_toolbar, BitmapUtils.DpToPixel(2, Resources)); }
public Bitmap Apply(Bitmap bitmap) { return(BitmapUtils.Binarization(bitmap, Threshold)); }
public static Bitmap CreateBitmap(string resource) { return(BitmapUtils.CreateBitmapFromUIImage(UIImage.FromFile(resource))); }
public void Export(TileModel model, TilePropagator propagator, string filename, DeBroglieConfig config, ExportOptions exportOptions) { if (config.Animate) { if (exportOptions is BitmapExportOptions) { var topoArray = propagator.ToWeightedArraySets().Map(WeightedColorAverage); var bitmap = BitmapUtils.ToBitmap(topoArray.ToArray2d()); bitmap.Save(filename); } else if (exportOptions is BitmapSetExportOptions bseo) { var topoArray = propagator.ToWeightedArraySets(); var tileTopology = topoArray.Topology.AsGridTopology().WithSize(bseo.TileWidth, bseo.TileHeight, 1); var subTiles = bseo.Bitmaps.ToDictionary(x => x.Key, x => TopoArray.Create(BitmapUtils.ToColorArray(x.Value), tileTopology).Map(c => new Tile(c))); var exploded = MoreTopoArrayUtils.ExplodeWeightedTiles(topoArray, subTiles, bseo.TileWidth, bseo.TileHeight, 1).Map(WeightedColorAverage); var bitmap = BitmapUtils.ToBitmap(exploded.ToArray2d()); bitmap.Save(filename); } else { throw new System.Exception($"Cannot export from {exportOptions.TypeDescription} to bitmap."); } } else { if (exportOptions is BitmapExportOptions) { var topoArray = propagator.ToValueArray(Rgba32.Gray, Rgba32.Magenta); var bitmap = BitmapUtils.ToBitmap(topoArray.ToArray2d()); bitmap.Save(filename); } else if (exportOptions is BitmapSetExportOptions bseo) { var undecided = new Tile(new object()); var contradiction = new Tile(new object()); var topoArray = propagator.ToArray(undecided, contradiction); var tileTopology = topoArray.Topology.AsGridTopology().WithSize(bseo.TileWidth, bseo.TileHeight, 1); var subTiles = bseo.Bitmaps.ToDictionary(x => x.Key, x => TopoArray.Create(BitmapUtils.ToColorArray(x.Value), tileTopology)); subTiles[undecided] = TopoArray.FromConstant(Rgba32.Gray, tileTopology); subTiles[contradiction] = TopoArray.FromConstant(Rgba32.Magenta, tileTopology); var exploded = MoreTopoArrayUtils.ExplodeTiles(topoArray, subTiles, bseo.TileWidth, bseo.TileHeight, 1); var bitmap = BitmapUtils.ToBitmap(exploded.ToArray2d()); bitmap.Save(filename); } else { throw new System.Exception($"Cannot export from {exportOptions.TypeDescription} to bitmap."); } } }
public Texture Get(TextureStateStruct *TextureState, ClutStateStruct *ClutState) { Texture Texture; //GC.Collect(); bool Swizzled = TextureState->Swizzled; uint TextureAddress = TextureState->Mipmap0.Address; uint ClutAddress = ClutState->Address; var ClutFormat = ClutState->PixelFormat; var ClutStart = ClutState->Start; var ClutDataStart = PixelFormatDecoder.GetPixelsSize(ClutFormat, ClutStart); ulong Hash1 = TextureAddress | (ulong)((ClutAddress + ClutDataStart) << 32); bool Recheck = false; if (Cache.TryGetValue(Hash1, out Texture)) { if (Texture.RecheckTimestamp != RecheckTimestamp) { Recheck = true; } } else { Recheck = true; } if (Recheck) { //Console.Write("."); //Console.WriteLine("{0:X}", ClutAddress); var TexturePointer = (byte *)PspMemory.PspAddressToPointerSafe(TextureAddress); var ClutPointer = (byte *)PspMemory.PspAddressToPointerSafe(ClutAddress); var TextureFormat = TextureState->PixelFormat; //var Width = TextureState->Mipmap0.TextureWidth; int BufferWidth = TextureState->Mipmap0.BufferWidth; var Height = TextureState->Mipmap0.TextureHeight; var TextureDataSize = PixelFormatDecoder.GetPixelsSize(TextureFormat, BufferWidth * Height); if (ClutState->NumberOfColors > 256) { ClutState->NumberOfColors = 256; } var ClutDataSize = PixelFormatDecoder.GetPixelsSize(ClutFormat, ClutState->NumberOfColors); var ClutCount = ClutState->NumberOfColors; var ClutShift = ClutState->Shift; var ClutMask = ClutState->Mask; //Console.WriteLine(TextureFormat); if (TextureDataSize > 2048 * 2048 * 4) { Console.Error.WriteLine("UPDATE_TEXTURE(TEX={0},CLUT={1}:{2}:{3}:{4}:0x{5:X},SIZE={6}x{7},{8},Swizzled={9})", TextureFormat, ClutFormat, ClutCount, ClutStart, ClutShift, ClutMask, BufferWidth, Height, BufferWidth, Swizzled); Console.Error.WriteLine("Invalid TEXTURE!"); return(new Texture()); } TextureCacheKey TextureCacheKey = new TextureCacheKey() { TextureAddress = TextureAddress, TextureFormat = TextureFormat, TextureHash = FastHash((uint *)TexturePointer, TextureDataSize), ClutHash = FastHash((uint *)&(ClutPointer[ClutDataStart]), ClutDataSize), ClutAddress = ClutAddress, ClutFormat = ClutFormat, ClutStart = ClutStart, ClutShift = ClutShift, ClutMask = ClutMask, Swizzled = Swizzled, }; if (Texture == null || (!Texture.TextureCacheKey.Equals(TextureCacheKey))) { #if DEBUG_TEXTURE_CACHE string TextureName = "texture_" + TextureCacheKey.TextureHash + "_" + TextureCacheKey.ClutHash + "_" + TextureFormat + "_" + ClutFormat + "_" + BufferWidth + "x" + Height; Console.Error.WriteLine("UPDATE_TEXTURE(TEX={0},CLUT={1}:{2}:{3}:{4}:0x{5:X},SIZE={6}x{7},{8},Swizzled={9})", TextureFormat, ClutFormat, ClutCount, ClutStart, ClutShift, ClutMask, BufferWidth, Height, BufferWidth, Swizzled); #endif Texture = new Texture(); Texture.TextureCacheKey = TextureCacheKey; { fixed(PixelFormatDecoder.OutputPixel *TexturePixelsPointer = DecodedTextureBuffer) { if (Swizzled) { fixed(byte *SwizzlingBufferPointer = SwizzlingBuffer) { Marshal.Copy(new IntPtr(TexturePointer), SwizzlingBuffer, 0, TextureDataSize); PixelFormatDecoder.UnswizzleInline(TextureFormat, (void *)SwizzlingBufferPointer, BufferWidth, Height); PixelFormatDecoder.Decode( TextureFormat, (void *)SwizzlingBufferPointer, TexturePixelsPointer, BufferWidth, Height, ClutPointer, ClutFormat, ClutCount, ClutStart, ClutShift, ClutMask ); } } else { PixelFormatDecoder.Decode( TextureFormat, (void *)TexturePointer, TexturePixelsPointer, BufferWidth, Height, ClutPointer, ClutFormat, ClutCount, ClutStart, ClutShift, ClutMask ); } #if DEBUG_TEXTURE_CACHE var Bitmap = new Bitmap(BufferWidth, Height); BitmapUtils.TransferChannelsDataInterleaved( Bitmap.GetFullRectangle(), Bitmap, (byte *)TexturePixelsPointer, BitmapUtils.Direction.FromDataToBitmap, BitmapChannel.Red, BitmapChannel.Green, BitmapChannel.Blue, BitmapChannel.Alpha ); Bitmap.Save(TextureName + ".png"); #endif Texture.SetData(TexturePixelsPointer, BufferWidth, Height); } } if (Cache.ContainsKey(Hash1)) { Cache[Hash1].Dispose(); } Cache[Hash1] = Texture; } } Texture.RecheckTimestamp = RecheckTimestamp; return(Texture); }
public override Carto.Graphics.Bitmap OnDrawPopup(PopupDrawInfo popupDrawInfo) { PopupStyle style = popupDrawInfo.Popup.Style; // Calculate scaled dimensions float DPToPX = popupDrawInfo.DPToPX; float PXTODP = 1 / DPToPX; if (style.ScaleWithDPI) { DPToPX = 1; } else { PXTODP = 1; } float screenWidth = popupDrawInfo.ScreenBounds.GetWidth() * PXTODP; float screenHeight = popupDrawInfo.ScreenBounds.GetHeight() * PXTODP; // Update sizes based on scale (uses extension method, cf. Shared/Extensions int fontSize = FontSize.Update(DPToPX); int triangleWidth = TriangleSize.Update(DPToPX); int triangleHeight = TriangleSize.Update(DPToPX); int strokeWidth = StrokeWidth.Update(DPToPX); int screenPadding = ScreenPadding.Update(DPToPX); // Set font var font = Android.Graphics.Typeface.Create("HelveticaNeue-Light", Android.Graphics.TypefaceStyle.Normal); // Calculate the maximum popup size, adjust with dpi int maxPopupWidth = (int)(Math.Min(screenWidth, screenHeight)); float halfStrokeWidth = strokeWidth * 0.5f; int maxTextWidth = maxPopupWidth - (2 * screenPadding + strokeWidth); // Measure text TextPaint textPaint = new TextPaint { Color = TextColor, TextSize = fontSize }; textPaint.SetTypeface(font); var textLayout = new StaticLayout(text, textPaint, maxTextWidth, Layout.Alignment.AlignNormal, 1, 0, false); int textX = (int)Math.Min(textPaint.MeasureText(text), textLayout.Width); int textY = textLayout.Height; int popupWidth = textX + (2 * PopupPadding + strokeWidth + triangleWidth); int popupHeight = textY + (2 * PopupPadding + strokeWidth); var bitmap = Android.Graphics.Bitmap.CreateBitmap(popupWidth, popupHeight, Android.Graphics.Bitmap.Config.Argb8888); var canvas = new Android.Graphics.Canvas(bitmap); var trianglePath = new Android.Graphics.Path(); trianglePath.MoveTo(triangleWidth, 0); trianglePath.LineTo(halfStrokeWidth, triangleHeight * 0.5f); trianglePath.LineTo(triangleWidth, triangleHeight); trianglePath.Close(); int triangleOffsetX = 0; int triangleOffsetY = (popupHeight - triangleHeight) / 2; // Create paint object var paint = new Android.Graphics.Paint(); paint.AntiAlias = true; paint.SetStyle(Android.Graphics.Paint.Style.Stroke); paint.StrokeWidth = strokeWidth; paint.Color = StrokeColor; // Stroke background var background = new Android.Graphics.RectF(); background.Left = triangleWidth; background.Top = halfStrokeWidth; background.Right = popupWidth - strokeWidth; background.Bottom = popupHeight - strokeWidth; canvas.DrawRect(background, paint); // Stroke triangle canvas.Save(); canvas.Translate(triangleOffsetX, triangleOffsetY); canvas.DrawPath(trianglePath, paint); canvas.Restore(); // Fill background paint.SetStyle(Android.Graphics.Paint.Style.Fill); paint.Color = BackgroundColor; canvas.DrawRect(background, paint); // Fill triangle canvas.Save(); canvas.Translate(triangleOffsetX, triangleOffsetY); canvas.DrawPath(trianglePath, paint); canvas.Restore(); if (textLayout != null) { // Draw text canvas.Save(); canvas.Translate(halfStrokeWidth + triangleWidth + PopupPadding, halfStrokeWidth + PopupPadding); textLayout.Draw(canvas); canvas.Restore(); } return(BitmapUtils.CreateBitmapFromAndroidBitmap(bitmap)); }
private static IDictionary <Tile, ITopoArray <Rgba32> > GetSubTiles(BitmapSetExportOptions bseo, out GridTopology subTileTopology) { var t = subTileTopology = new GridTopology(bseo.TileWidth, bseo.TileHeight, false); return(bseo.Bitmaps.ToDictionary(x => x.Key, x => TopoArray.Create(BitmapUtils.ToColorArray(x.Value), t))); }
/// <summary> /// Returns the <see cref="DocumentInspectorPageOrientation"/> of the <paramref name="bitmap"/> /// according to the text that is on it /// </summary> /// <param name="bitmap">The bitmap with text</param> /// <returns></returns> public DocumentInspectorPageOrientation DetectPageOrientation(Bitmap bitmap) { if (bitmap == null) { throw new NullReferenceException("The bitmap parameter is not set"); } if (bitmap.PixelFormat == PixelFormat.Format1bppIndexed) { bitmap = BitmapUtils.CopyToBpp(bitmap, 8); } using (var engine = new TesseractEngine(TesseractDataPath, TesseractLanguage)) { var rect = new Rect(); using (var image = PixConverter.ToPix(bitmap)) using (var page = engine.Process(image, PageSegMode.AutoOsd)) { var pageIterator = page.AnalyseLayout(); pageIterator.Begin(); while (pageIterator.Next(PageIteratorLevel.Block)) { var found = false; while (pageIterator.Next(PageIteratorLevel.Para)) { var counter = 0; while (pageIterator.Next(PageIteratorLevel.TextLine, PageIteratorLevel.Word)) { counter++; } if (counter < 5) { continue; } found = pageIterator.TryGetBoundingBox(PageIteratorLevel.TextLine, out rect); break; } var croppedRect = new Rectangle(rect.X1, rect.Y1, rect.Width, rect.Height); if (rect.Height == 0) { return(DocumentInspectorPageOrientation.Undetectable); } var croppedImage = found ? bitmap.Clone(croppedRect, bitmap.PixelFormat) : bitmap.Clone() as Bitmap; // The OCR confidence on the first run float firstMeanConfedence; // The OCR confidence on the second run float secondMeanConfedence; using (var engineCroppedImage = new TesseractEngine(TesseractDataPath, TesseractLanguage)) { using (var imageNormal = PixConverter.ToPix(croppedImage)) using (var pageNormal = engineCroppedImage.Process(imageNormal)) firstMeanConfedence = pageNormal.GetMeanConfidence(); if (firstMeanConfedence > 0.75) { return(DocumentInspectorPageOrientation.PageCorrect); } // Rotate image 180 degrees croppedImage.RotateFlip(RotateFlipType.Rotate180FlipNone); //croppedImage.Save(@"d:\\Crop area flipped.tif", System.Drawing.Imaging.ImageFormat.Tiff); using (var imageRotated180 = PixConverter.ToPix(croppedImage)) using (var pageRotated180 = engineCroppedImage.Process(imageRotated180)) secondMeanConfedence = pageRotated180.GetMeanConfidence(); } croppedImage.Dispose(); if (firstMeanConfedence > 0.40 && secondMeanConfedence > 0.40) { return(firstMeanConfedence >= secondMeanConfedence ? DocumentInspectorPageOrientation.PageCorrect : DocumentInspectorPageOrientation.PageUpsideDown); } } } return(DocumentInspectorPageOrientation.Undetectable); } }
public Bitmap Apply(Bitmap bitmap) { return(BitmapUtils.GrayImage(bitmap, this.Type)); }