Uma técnica fundamental em aplicativos de edição de imagens é determinar as cores dominantes. A identificação dessas cores dominantes é essencial para a criação de uma paleta de imagens, que, por sua vez, reflete com precisão o efeito das ferramentas selecionadas e os resultados da edição.  Este artigo se aprofundará em como determinar a paleta de uma imagem dentro de um espaço de cores restrito, identificar as cores dominantes de uma imagem e diferenciar entre uma paleta e as cores dominantes.   Paleta  A paleta da imagem normalmente é uma referência a todas as cores presentes na imagem original. Em essência, ele captura toda a gama de tonalidades de cores, com base na escala numérica dos valores do sinal de estímulo de cor.  Se concordarmos em modelar um sinal com um certo nível de precisão, então a faixa desses valores de sinal representará nossa paleta de cores disponível.  Cada representação única de uma imagem e o mapeamento das cores de uma imagem neste espaço serão um subconjunto dela. No processamento digital de sinais (uma imagem também é um sinal), muitas vezes entendemos uma variedade de quantidades através da sua representação discreta.  Assim, nossa paleta de imagens pode ser vista como um subconjunto de todas as cores da imagem representada por um mapa discreto. Cada cor pode ser indexada e receber um valor específico em um dos espaços de cores. Para nossos propósitos, usaremos o modelo de cores RGB.  Um desafio significativo na apresentação da paleta de imagens desta forma é a vastidão da visibilidade humana. É improvável que possamos analisar manualmente toda a paleta de imagens e muitas vezes não faz sentido armazenar uma imagem representada por todas as cores originais. Em vez disso, reduzimos o seu número a um limite razoável.  Este processo, conhecido como quantização de cores, envolve a redução do número de cores do subconjunto completo que pode ser representado em uma imagem para um menor. Por exemplo, dados de cores brutas de 14 bits podem ser representados em JPEG de 8 bits ou TIFF de 16 bits convertidos em PNG de 8 bits.  Uma solução simples para determinar as cores primárias de uma imagem é imaginar o processo de quantização de cores para um conjunto muito limitado, como 8 ou até 3 cores. Isso nos dá uma visão das cores primárias da imagem, tornando-as mais perceptíveis e memoráveis.  O ideal é que as cores da imagem final sejam harmoniosas, seguindo os princípios traçados por   ou   . Johannes Itten Matyushin  Ao identificar as cores dominantes de uma imagem, podemos criar uma ferramenta que nos permite visualizar a “harmonia” da imagem. Isto também pode se aplicar à harmonia da imagem após a filtragem, ou “harmonização sintética”.  A seguir, tentaremos desenvolver tal ferramenta.    Corte Mediano  Um algoritmo amplamente utilizado e de alta qualidade para compactar a paleta de uma imagem é o algoritmo Median Cut. Ele é incorporado à maioria dos principais algoritmos de compactação de imagens com perdas, como JPEG, embora com algumas modificações.  O princípio fundamental do algoritmo Median Cut é dividir sequencialmente o histograma cúbico da imagem em medianas. Cada subcubo resultante contém aproximadamente um número igual de caixas ou pixels da mesma cor.  Uma vez que o processo de divisão atinge um número predeterminado de subcubos, calculamos a cor média de cada cubo e mapeamos-a para as cores correspondentes da imagem original. Esse processo reduz efetivamente o número de cores na imagem original, permitindo compactar a imagem em um tamanho de arquivo menor.  À primeira vista, pode parecer que a parte inicial deste algoritmo poderia resolver o nosso problema de identificação das cores primárias ou dominantes de uma imagem. No entanto, surge um problema potencial quando o número de cores em que dividimos a imagem é muito pequeno e estamos analisando apenas um pequeno número de cores.  Podemos acabar identificando cores que realmente não existem na imagem porque as cores são excessivamente médias. Poderíamos escolher a cor com o máximo de cada cubo e rotulá-la como dominante, mas então ela não constituiria mais uma paleta.  Portanto, reservaremos esta abordagem para determinar     da paleta da imagem, que também pode ser usada como ferramenta para analisar visualmente a imagem em termos de sua “utilidade harmoniosa”. Para identificar as cores dominantes, empregaremos análise estatística: busca de máximos locais no mesmo histograma cúbico. uma versão compactada   Máximos locais  Para identificar os máximos locais, implementaremos um código específico. O autor, que também é um artista habilidoso, fornece uma excelente descrição do algoritmo. Essencialmente, primeiro reunimos as estatísticas da imagem no mesmo histograma RGB tridimensional usado no algoritmo Median Cut.   Cada célula do histograma cúbico conterá caixas de cores e a soma de todos os valores de cada cor incluída na célula. Dada a dimensão limitada do histograma para uma resolução de 32x32x32 (originalmente 30x30x30), acumular a soma simplifica o cálculo da cor média da célula.   Em seguida, procuramos o máximo local explorando minuciosamente todo o espaço e comparando-o com as células vizinhas.   Em seguida, reduzimos iterativamente o número de máximos locais até a quantidade necessária, descartando cores semelhantes com menor peso. Para todos os máximos locais restantes, calculamos as cores médias de todos os valores incluídos na lista.  Como a densidade de cores nos máximos locais é maior e a diferença entre os valores dos pixels é menor do que nos cubos do Corte Mediano, as cores serão mais parecidas com as presentes na imagem principal e representarão com mais precisão suas cores dominantes.  Isto revela a principal diferença entre os dois modelos: adquirir uma   versus procurar máximos locais ou   . Ao mapear a imagem primária da "paleta compactada", criaremos uma nova   , embora de uma forma bastante truncada. “paleta comprimida” cores dominantes que mantém o mesmo equilíbrio de cores da imagem principal  Por outro lado, as cores dominantes     . Eles não podem ser transformados em nada novo com um equilíbrio de cores adequado. descrevem apenas a composição das cores presentes principalmente na imagem   Implementação  Usando esta tarefa como exemplo, demonstraremos como é simples desenvolver um aplicativo pronto para uso para análise e manipulação de imagens usando o   . Começaremos com funcionalidades que estão ausentes em outros motores. IMProcessing Framework  Por exemplo, a estrutura tem a capacidade de ler arquivos Adobe   com CLUTs pré-existentes e pode extrair um histograma cúbico tridimensional de uma imagem em tempo real. .cube  Aproveitando isso, pretendemos criar um aplicativo que possa:  Faça upload de arquivos no formato JFIF (jpeg).  “Normalizar” a imagem original.  Controle a intensidade do “normalizador”.  Incorpore uma LUT arbitrária de um arquivo Adobe .cube no processamento.  Gerencie a intensidade do impacto do CLUT.  Exiba um histograma linear da imagem.  Exiba a “paleta compactada” e as cores dominantes da imagem, bem como sua representação numérica na forma de um trio (r,g,b)  O produto final da nossa construção será semelhante a este brinquedo interativo:   Aqui fica claro como a simples “normalização” da imagem influencia positivamente a diversidade da paleta final, redistribuindo as cores dominantes num conjunto mais variado e harmonioso.   "Normalizador"  Montaremos um filtro a partir de dois pré-existentes:    - permite esticar o histograma da imagem até limites especificados IMPContrastFilter    - realiza a correção automática do balanço de branco com base na busca pela cor média e na correção de tons espúrios na imagem. Esta é essencialmente uma ligeira modificação de uma ideia emprestada do  IMPAutoWBFilter  . blog de Andrey Zhuravlev   import IMProcessing /// Image filter public class IMPTestFilter:IMPFilter { /// We will use a contrast control filter through histogram stretching var contrastFilter:IMPContrastFilter! /// Auto white balance filter var awbFilter:IMPAutoWBFilter! /// Image Linear Histogram Analyzer var sourceAnalyzer:IMPHistogramAnalyzer! /// Solver of the histogram analyzer for calculating the lightness boundaries of the image let rangeSolver = IMPHistogramRangeSolver() public required init(context: IMPContext) { super.init(context: context) // Initialize filters in context contrastFilter = IMPContrastFilter(context: context) awbFilter = IMPAutoWBFilter(context: context) // Add filters to the stack addFilter(contrastFilter) addFilter(awbFilter) // Initialize the histogram analyzer sourceAnalyzer = IMPHistogramAnalyzer(context: self.context) // Add a light boundary search solver to the analyzer sourceAnalyzer.addSolver(rangeSolver) // Add an observing handler to the filter for // to pass the current image frame to the analyzer addSourceObserver { (source) - Void in self.sourceAnalyzer.source = source } // Add an observing handler for updating analysis calculations to the analyzer sourceAnalyzer.addUpdateObserver({ (histogram) - Void in // set the lightness boundaries in the contrast filter each time the image changes self.contrastFilter.adjustment.minimum = self.rangeSolver.minimum self.contrastFilter.adjustment.maximum = self.rangeSolver.maximum }) } }   Solucionador de paleta  O IMProcessing Framework se destaca de muitas plataformas semelhantes devido à sua organização única de cálculos. Ele usa um grupo dedicado de filtros que essencialmente não são filtros de processamento.  Os objetos destas classes não modificam a imagem nos domínios homogêneo e espacial. Em vez disso, eles realizam determinados cálculos e representações de métricas para análise em expansores especiais para resolver problemas específicos.  Por exemplo, um objeto da classe IMPHistogramAnalyzer pode adicionar simultaneamente vários solucionadores que calculam a cor média da imagem, o alcance da luz, a divisão zonal, etc.  Usamos o solucionador para estender a análise do IMPHistogramCubeAnalyzer para calcular a paleta e a lista de cores dominantes. Os resultados do cálculo são então exibidos em um NSTableView atualizado.   import IMProcessing /// Types of distribution of image color accents /// /// - palette: palette for quantizing image colors. /// calculated using the median-cut transformation scheme: /// http://www.leptonica.com/papers/mediancut.pdf /// - dominants: calculation of dominant colors of an image by searching for local maxima /// color distribution density functions: /// https://github.com/pixelogik/ColorCube /// public enum IMPPaletteType{ case palette case dominants } /// Solver of the cubic color histogram analyzer IMPHistogramCubeAnalyzer public class IMPPaletteSolver: IMPHistogramCubeSolver { /// Maximum number of palette colors for analysis public var maxColors = Int(8) /// List of found colors public var colors = [IMPColor]() /// Palette type public var type = IMPPaletteType.dominants /// Solver handler handler /// - parameter analyzer: link to the analyzer /// - parameter histogram: cubic histogram of the image /// - parameter imageSize: image size public func analizerDidUpdate(analizer: IMPHistogramCubeAnalyzer, histogram: IMPHistogramCube, imageSize: CGSize) { var p = [float3]() if type == .palette{ p = histogram.cube.palette(count: maxColors) } else if type == .dominants { p = histogram.cube.dominantColors(count: maxColors) } colors.removeAll() for c in p { colors.append(IMPColor(color: float4(rgb: c, a: 1))) } } }   Montamos todos os componentes no View Controller  O controlador precisará do filtro principal do aplicativo, que chamaremos de   , um filtro CLUT chamado IMPLutFilter, o IMPHistogramView pronto para uso para exibir um histograma "regular", o IMPHistogramCubeAnalyzer que é um analisador de histograma cúbico ao qual anexaremos nosso solucionador, o IMPPaletteSolver. IMPTestFilter  Por fim, usaremos IMPImageView como janela principal para exibição da imagem, e o IMPContext comum é a classe chave usada por todos os construtores do framework.   class ViewController: NSViewController { // // Processing context // let context = IMPContext() // // Window for presenting the loaded image // var imageView:IMPImageView! var pannelScrollView = NSScrollView() // // Window for displaying the image histogram // var histogramView:IMPHistogramView! // // NSTableView - views of a list of colors from the palette // var paletteView:IMPPaletteListView! // // Main filter // var filter:IMPTestFilter! // // CLUT filter from Adobe Cube files // var lutFilter:IMPLutFilter? // // Analyzer of a cubic histogram of an image in RGB space // var histograCube:IMPHistogramCubeAnalyzer! // // Our solver for finding colors // var paletteSolver = IMPPaletteSolver() var paletteTypeChooser:NSSegmentedControl! override func viewDidLoad() { super.viewDidLoad() configurePannel() // // Initialize the objects we need // filter = IMPTestFilter(context: context) histograCube = IMPHistogramCubeAnalyzer(context: context) histograCube.addSolver(paletteSolver) imageView = IMPImageView(context: context, frame: view.bounds) imageView.filter = filter imageView.backgroundColor = IMPColor(color: IMPPrefs.colors.background) // // Add another handler to monitor the original image // (another one was added in the main filter IMPTestFilter) // filter.addSourceObserver { (source) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in // // to minimize calculations, the analyzer will compress the image to 1000px on the wide side // if let size = source.texture?.size { let scale = 1000/max(size.width,size.height) self.histograCube.downScaleFactor = scale.float } } // Add an observer to the filter to process the filtering results // filter.addDestinationObserver { (destination) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in // pass the image to the histogram indicator self.histogramView.source = destination // pass the result to the cubic histogram analyzer self.histograCube.source = destination } // // The results of updating the analyzer calculation are displayed in the color list window // histograCube.addUpdateObserver { (histogram) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in self.paletteView.colorList = self.paletteSolver.colors }) } view.addSubview(imageView) .... IMPDocument.sharedInstance.addDocumentObserver { (file, type) -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in if type == .Image { do{ // // Load the file and associate it with the filter source // self.imageView.source = try IMPImageProvider(context: self.imageView.context, file: file) self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in self.zoomFit() }) } catch let error as NSError { self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in let alert = NSAlert(error: error) alert.runModal() }) } } else if type == .LUT { do { // // Initialize the CLUT descriptor // var description = IMPImageProvider.LutDescription() // // Load CLUT // let lutProvider = try IMPImageProvider(context: self.context, cubeFile: file, description: &amp;amp;amp;amp;amp;amp;amp;amp;amp;description) if let lut = self.lutFilter{ // // If a CLUT filter has been added, update its LUT table from the file with the received descriptor // lut.update(lutProvider, description:description) } else{ // // Create a new LUT filter // self.lutFilter = IMPLutFilter(context: self.context, lut: lutProvider, description: description) } // // Add a LUT filter, if this filter has already been added nothing happens // self.filter.addFilter(self.lutFilter!) } catch let error as NSError { self.asyncChanges({ () -&amp;amp;amp;amp;amp;amp;amp;amp;gt; Void in let alert = NSAlert(error: error) alert.runModal() }) } } } ....  Como você pode ver, o processamento de fotos está se tornando mais simples e acessível ao usuário médio, possibilitando que praticamente qualquer pessoa domine esse processo.  O projeto inteiro pode ser baixado, montado e testado no   do projeto   :   . Para uma montagem adequada, a megabiblioteca para trabalhar com arquivos JPEG (JFIF),   , deve ser instalada localmente. repositório ImageMetalling ImageMetalling-08 libjpeg-turbo  Atualmente, esta é a melhor implementação de suporte para este formato.

Read My Stories

Este áudio é produzido no idioma original da história!

Como criar um aplicativo para determinar a paleta e as cores dominantes de uma imagem

About Author

COMENTARIOS

Rótulos

ESTE ARTIGO FOI APRESENTADO EM

Related Stories

Criando produtos criptográficos centrados no usuário: a importância do feedback do cliente

Aumente sua produtividade com estas 18 ferramentas para desenvolvedores 🚀🔥

Uma breve introdução à teoria do cérebro de Boltzmann

O guia completo para uma migração bem-sucedida para a nuvem: estratégias e práticas recomendadas

Criando produtos criptográficos centrados no usuário: a importância do feedback do cliente

Aumente sua produtividade com estas 18 ferramentas para desenvolvedores 🚀🔥

Uma breve introdução à teoria do cérebro de Boltzmann

O guia completo para uma migração bem-sucedida para a nuvem: estratégias e práticas recomendadas

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps