怎么从图像中删除白色

嗨，B祝福，你不能使用进度条窗口顶部的线条小部件来显示刻痕吗？这可能是一项工作，有更多的蜱，但你应该能够复制和粘贴小部件在MHGC。谢谢，Ed @ Microchip



      以下为原文

   


Hi bblessing,
 
  Can't you use the line widgets on top of the progress bar widget to show the tick marks? It may be a bit of work with more ticks, but you should be able to copy-and-paste widgets in MHGC.
 
Thanks,
 
Ed@Microchip

这是真的，但非常乏味。此外，销售和管理类型倾向于一时兴起改变主意，我无法跟上这一点。我开始怀疑Segger emWin图形是不是该走的路。我相信Microchip在某些时候会达到一个非常有竞争力的水平，但是对于EMWIN来说，这是一个越来越高的价格，考虑到创建定制小部件所需的工时数，你看不到商业上的锐利。我再怎么强调你们花在这些事情上的时间我都不太重视。



      以下为原文

    That is true, but it's extremely tedious. Moreover, sales and management types are prone to changing their minds on a whim, and I wouldn't be able to keep up with that.
 
I'm beginning to wonder if Segger emWin graphics are the way to go. I'm sure Microchip will get Harmony to a very competitive level at some point, but that steep price tag for emWin is looking better and better given the number of man hours it takes to create custom widgets that in no way look as sharp what you see commercially.
 
Thank you for your response, though! I can't emphasize enough how much I appreciate the hours you guys spend on these things.

不，emWinis Free，如果你在PIC32上使用它的话。



      以下为原文

   


No, emWin is Free if you use it on a PIC32 ( At leat it was.

如果你在CPU上做BLIT，它看起来是什么样的？我知道GPU是一种挑剔的面具颜色和选定的ROPS。我还记得，NANDA 2D二进制库有一个问题，掩饰是固定在2.04之前出去。我们最近还发现，当DAGPU在缓存大小不超过2的缓冲区时可能会出现问题。这里我所说的代码是用于掩蔽的（NAND2D包装器）：这里是我刚才添加的功能函数，即预创建图像：创建复杂的小部件不是一个快速的P。摇滚乐。我认为编辑一个图像来获得你想要的外观和感觉要花的时间要少得多。为了让整个工具链认识到你的小部件，你需要创建两个Java插件，然后是实际的C实现。这整个流程的文档仍然是一个正在进行中的工作。



      以下为原文

    What does it look like if you do the blit on the CPU?  I know the GPU is kind of picky with the mask color and the selected ROPs.  I also recall that the nano2d binary library had an issue with masking that was fixed just before 2.04 went out.  We also recently discovered that the DA GPU can have issues when blitting buffers that aren't sized to a power of 2.
 
Here's the code that I'm told is working for masking (nano2d wrapper):
 
 
 
static GFX_Result drawBlit(const GFX_PixelBuffer* source,
                           const GFX_Rect* srcRect,
                           const GFX_Point* drawPoint,
                           const GFX_DrawState* state)
{
    n2d_buffer_t src_buffer, dest_buffer;
    GFX_Rect dest_rect;
    
    // the source address must reside in KSEG1 (cache coherent) memory
    // and the source buffer must be raw pixels as the the GPU doesn't
    // understand palettized blits
    // if this fails then fall back to software mode
    if(IS_KVA1(source->pixels) == GFX_FALSE ||
       GFX_COLOR_MODE_IS_INDEX(source->mode) == GFX_TRUE ||
       GFX_COLOR_MODE_IS_INDEX(state->target->mode) == GFX_TRUE ||
       n2dFormats[source->mode] == -1 ||
       n2dFormats[state->colorMode] == -1 ||
       srcRect->width * srcRect->height < MAX_PROCESS_AREA)
        return cpuDrawBlit(source, srcRect, drawPoint, state);
    
    // craft source buffer descriptor
    src_buffer.width = source->size.width;
    src_buffer.height = source->size.height;
    src_buffer.stride = source->size.width * GFX_ColorInfo[source->mode].size;
    src_buffer.format = n2dFormats[source->mode];
    src_buffer.orientation = N2D_0;
    src_buffer.handle = NULL;
    src_buffer.memory = source->pixels;
    src_buffer.gpu = KVA_TO_PA(source->pixels);
       
    // craft dest buffer descriptor
    dest_buffer.width = state->target->size.width;
    dest_buffer.height = state->target->size.height;
    dest_buffer.stride = state->target->size.width * GFX_ColorInfo[state->colorMode].size;
    dest_buffer.format = n2dFormats[state->target->mode];
    dest_buffer.orientation = N2D_0;
    dest_buffer.handle = NULL;
    dest_buffer.memory = state->target->pixels;
    dest_buffer.gpu = KVA_TO_PA(state->target->pixels);
    
    dest_rect.x = drawPoint->x;
    dest_rect.y = drawPoint->y;
    dest_rect.width = srcRect->width;
    dest_rect.height = srcRect->height;
    
    if(state->maskEnable == GFX_TRUE)
    {
        n2d_color_t color = (n2d_color_t)state->maskValue;
        
        n2d_draw_state(N2D_TRANSPARENCY_SOURCE,
                       color,
                       0xA,
                       0xC);
    }
    n2d_blit(&dest_buffer,
             (n2d_rectangle_t*)&dest_rect,
             &src_buffer,
             (n2d_rectangle_t*)srcRect,
             N2D_BLEND_NONE);
    
    if(state->maskEnable == GFX_TRUE)
    {
        n2d_draw_state(N2D_TRANSPARENCY_NONE, 0, 0xC, 0xC);
    }
    
    return GFX_SUCCESS;
}
 
And here's the utility function that I just added that prestages images:
 

 
GFX_Result GFXU_PreprocessImage(GFXU_ImageAsset* img,
                                uint32_t destAddress,
                                GFX_ColorMode destMode,
                                GFX_Bool padBuffer)
{
    GFX_PixelBuffer buf;
    uint32_t width = img->width;
    uint32_t height = img->height;
    uint32_t p;
    GFX_Rect rect;
    
    if(img->header.dataLocation != 0)
        return 0;
    
    if(padBuffer == GFX_TRUE)
    {
        if(width && !(width & (width - 1)) == 0)
        {
            p = 1;
            
            while(width >= p)
                p <<= 1;
            
            width = p;
        }
        
        if(height && !(height & (height - 1)) == 0)
        {
            p = 1;
            
            while(height >= p)
                p <<= 1;
            
            height = p;
        }
    }   
    
    GFX_PixelBufferCreate(width,
                          height,
                          destMode,
                          (void*)destAddress,
                          &buf);
    
    if((img->flags & GFXU_IMAGE_USE_MASK) > 0)
    {
        rect.x = 0;
        rect.y = 0;
        rect.width = buf.size.width;
        rect.height = buf.size.height;
        
        GFX_PixelBufferAreaFill(&buf, &rect, GFX_ColorConvert(img->colorMode, destMode, img->mask));
    }
    else
    {
        memset(buf.pixels, 0, buf.buffer_length);
    }
    
    GFX_Set(GFXF_DRAW_TARGET, &buf);
    
    GFX_Begin();
    GFXU_DrawImage(img,
                   0,
                   0,
                   img->width,
                   img->height,
                   0,
                   0,
                   NULL,
                   NULL);
    GFX_End();
    
    GFX_Set(GFXF_DRAW_TARGET, NULL);
    
    img->header.dataAddress = (void*)destAddress;
    img->header.dataLocation = 0;
    img->header.dataSize = buf.buffer_length;
    img->bufferWidth = buf.size.width;
    img->bufferHeight = buf.size.height;
    img->format = GFXU_IMAGE_FORMAT_RAW;
    img->compType = GFXU_IMAGE_COMPRESSION_NONE;
    
    if((img->flags & GFXU_IMAGE_USE_MASK) > 0)
        img->mask = GFX_ColorConvert(img->colorMode, destMode, img->mask);
    else
        img->mask = 0;
    
    img->palette = NULL;
    img->colorMode = destMode;
    
    return GFX_SUCCESS;
}
 

 
Creating complex widgets is not a quick process.  I would think it takes far less time to edit an image to get the exact look and feel you want.  In order to get the entire toolchain to recognize your widget you'd need to create two java plugins and then the actual C implementation.  Documention of this entire flow is still a work in progress.