colors mouse - ¿Cambiar el color de la imagen PNG vía CSS?




con invertir (13)

Dado un PNG transparente que muestra una forma simple en blanco, ¿es posible cambiar el color de este a través de CSS? ¿Algún tipo de superposición o qué no?


Answers

Si :)

Surfin 'Safari - Blog Archive »Máscaras CSS

WebKit ahora soporta máscaras alfa en CSS. Las máscaras le permiten superponer el contenido de un cuadro con un patrón que se puede usar para eliminar partes de ese cuadro en la pantalla final. En otras palabras, puede recortar a formas complejas basadas en el alfa de una imagen.
[...]
Hemos introducido nuevas propiedades para proporcionar a los diseñadores web un gran control sobre estas máscaras y cómo se aplican. Las nuevas propiedades son análogas a las propiedades de fondo y de imagen de borde que ya existen.

-webkit-mask (background)
-webkit-mask-attachment (background-attachment)
-webkit-mask-clip (background-clip)
-webkit-mask-origin (background-origin)
-webkit-mask-image (background-image)
-webkit-mask-repeat (background-repeat)
-webkit-mask-composite (background-composite)
-webkit-mask-box-image (border-image)

Respondiendo porque estaba buscando una solución para esto.

La respuesta de la pluma en @chrscblls funciona bien si tienes un fondo blanco o negro, pero el mío no. Además, las imágenes se generaron con ng-repeat, así que no pude tener su url en mi css Y no se puede usar :: after en img tags.

Entonces, pensé en una solución y pensé que podría ayudar a la gente si también tropiezan aquí.

Entonces, lo que hice es casi lo mismo con tres diferencias principales:

  • la url está en mi etiqueta img, la puse (y una etiqueta) en otra div en la que :: después funcionará.
  • el 'modo de mezcla de mezcla' se establece en 'diferencia' en lugar de 'multiplicar' o 'pantalla'.
  • Agregué un :: antes con exactamente el mismo valor, de modo que el :: después haría la 'diferencia' de la 'diferencia' hecha por el :: antes y se cancelaba.

Para cambiarlo de negro a blanco o de blanco a negro, el color de fondo debe ser blanco. Desde el negro hasta los colores, puedes elegir cualquier color. Desde el blanco hasta los colores, tendrás que elegir el color opuesto al que quieras.

.divClass{
   position: relative;
   width: 100%;
   height: 100%;
   text-align: left;
}
.divClass:hover::after, .divClass:hover::before{
   position: absolute;
   width: 100%;
   height: 100%;
   background: #FFF;
   mix-blend-mode: difference;
   content: "";
}

https://codepen.io/spaceplant/pen/oZyMYG


En la caniuse.com/#feat=css-filters , puedes usar filtros:

  • tanto en los elementos <img> como en las imágenes de fondo de otros elementos

  • y configúralos de forma estática en tu CSS, o dinámicamente usando JavaScript

Ver demos abajo.

<img> elementos

Puedes aplicar esta técnica a un elemento <img> :

#original, #changed {
    width: 45%;
    padding: 2.5%;
    float: left;
}

#changed {
    -webkit-filter : hue-rotate(180deg);
    filter : hue-rotate(180deg);
}
<img id="original" src="http://i.stack.imgur.com/rfar2.jpg" />

<img id="changed" src="http://i.stack.imgur.com/rfar2.jpg" />

Imagenes de fondo

Puedes aplicar esta técnica a una imagen de fondo:

#original, #changed {
    background: url('http://i.stack.imgur.com/kaKzj.jpg');
    background-size: cover;
    width: 30%;
    margin: 0 10% 0 10%;
    padding-bottom: 28%;
    float: left;
}

#changed {
    -webkit-filter : hue-rotate(180deg);
    filter : hue-rotate(180deg);
}
<div id="original"></div>

<div id="changed"></div>

JavaScript

Puede usar JavaScript para establecer un filtro en tiempo de ejecución:

var element = document.getElementById("changed");
var filter = 'hue-rotate(120deg) saturate(2.4)';
element.style['-webkit-filter'] = filter;
element.style['filter'] = filter;
#original, #changed {
    margin: 0 10%;
    width: 30%;
    float: left;
    background: url('http://i.stack.imgur.com/856IQ.png');
    background-size: cover;
    padding-bottom: 25%;
}
<div id="original"></div>

<div id="changed"></div>


Encontré esto mientras buscaba en Google, lo mejor fue trabajar para mí ...

HTML

<div class="img"></div>

CSS

.img {
  background-color: red;
  width: 60px;
  height: 60px;
   -webkit-mask-image: url('http://i.stack.imgur.com/gZvK4.png');
}

http://jsfiddle.net/a63b0exm/


Puede usar filtros con -webkit-filter y filter : los filtros son muy nuevos para los navegadores y solo son compatibles con los navegadores muy modernos. Puede cambiar una imagen a escala de grises, sepia y mucho más (vea el ejemplo).

Así que ahora puedes cambiar el color de un archivo PNG con filtros.

body {
    background-color:#03030a;
    min-width: 800px;
    min-height: 400px
}
img {
    width:20%;
    float:left; 
     margin:0;
}
/*Filter styles*/
.saturate { filter: saturate(3); }
.grayscale { filter: grayscale(100%); }
.contrast { filter: contrast(160%); }
.brightness { filter: brightness(0.25); }
.blur { filter: blur(3px); }
.invert { filter: invert(100%); }
.sepia { filter: sepia(100%); }
.huerotate { filter: hue-rotate(180deg); }
.rss.opacity { filter: opacity(50%); }
<!--- img src http://upload.wikimedia.org/wikipedia/commons/thumb/e/ec/Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg/500px-Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg -->
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="original">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="saturate" class="saturate">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="grayscale" class="grayscale">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="contrast" class="contrast">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="brightness" class="brightness">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="blur" class="blur">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="invert" class="invert">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="sepia" class="sepia">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="huerotate" class="huerotate">
<img alt="Mona Lisa" src="http://i.stack.imgur.com/OyP0g.jpg" title="opacity" class="rss opacity">

Source


Es posible que desee echar un vistazo a las fuentes de icono. http://css-tricks.com/examples/IconFont/

EDITAR: Estoy usando Font-Awesome en mi último proyecto. Incluso puedes arrancarlo. Simplemente ponga esto en su <head> :

<link href="//netdna.bootstrapcdn.com/font-awesome/3.2.1/css/font-awesome.min.css" rel="stylesheet">

<!-- And if you want to support IE7, add this aswell -->
<link href="//netdna.bootstrapcdn.com/font-awesome/3.2.1/css/font-awesome-ie7.min.css" rel="stylesheet">

Y luego adelante y agrega algunos íconos como este:

<a class="icon-thumbs-up"></a>

Aquí está la hoja de trucos completa

--editar--

Font-Awesome usa diferentes nombres de clase en la nueva versión, probablemente porque esto hace que los archivos CSS sean drásticamente más pequeños, y para evitar clases de css ambiguas. Así que ahora deberías usar:

<a class="fa fa-thumbs-up"></a>

EDIT 2:

Acabo de descubrir que github también usa su propia fuente de icono: Octicons Es gratis para descargar. También tienen algunos consejos sobre cómo crear sus propias fuentes de iconos .


Necesitaba un color específico, así que el filtro no me funcionó.

En su lugar, creé un div, explotando varias imágenes de fondo CSS y la función de gradiente lineal (que crea una imagen en sí misma). Si usa el modo de mezcla de superposición, su imagen real se combinará con la imagen "degradada" generada que contiene el color deseado (aquí, # BADA55)

.colored-image {
        background-image: linear-gradient(to right, #BADA55, #BADA55), url("https://i.imgur.com/lYXT8R6.png");
        background-blend-mode: overlay;
        background-size: contain;
        width: 200px;
        height: 200px;        
    }
<div class="colored-image"></div>


He podido hacer esto usando el filtro SVG. Puede escribir un filtro que multiplique el color de la imagen de origen con el color que desea cambiar. En el fragmento de código a continuación, el color de la inundación es el color al que queremos cambiar el color de la imagen (que en este caso es rojo). FeComposite le dice al filtro cómo procesamos el color. La fórmula para feComposite con aritmética es (k1 * i1 * i2 + k2 * i1 + k3 * i2 + k4) donde i1 e i2 son colores de entrada para in / in2 en consecuencia. Por lo tanto, especificar solo k1 = 1 significa que solo hará i1 * i2, lo que significa multiplicar ambos colores de entrada juntos.

Nota: Esto solo funciona con HTML5 ya que utiliza SVG en línea. Pero creo que podrías hacer que esto funcione con un navegador más antiguo al colocar SVG en un archivo separado. No he probado ese enfoque todavía.

Aquí está el fragmento:

<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="60" height="90" style="float:left">
  <defs>
    <filter id="colorMask1">
      <feFlood flood-color="#ff0000" result="flood" />
      <feComposite in="SourceGraphic" in2="flood" operator="arithmetic" k1="1" k2="0" k3="0" k4="0" />
    </filter>
  </defs>
  <image width="100%" height="100%" xlink:href="http://i.stack.imgur.com/OyP0g.jpg" filter="url(#colorMask1)" />
</svg>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="60" height="90" style="float:left">
  <defs>
    <filter id="colorMask2">
      <feFlood flood-color="#00ff00" result="flood" />
      <feComposite in="SourceGraphic" in2="flood" operator="arithmetic" k1="1" k2="0" k3="0" k4="0" />
    </filter>
  </defs>
  <image width="100%" height="100%" xlink:href="http://i.stack.imgur.com/OyP0g.jpg" filter="url(#colorMask2)" />
</svg>
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="60" height="90" style="float:left">
  <defs>
    <filter id="colorMask3">
      <feFlood flood-color="#0000ff" result="flood" />
      <feComposite in="SourceGraphic" in2="flood" operator="arithmetic" k1="1" k2="0" k3="0" k4="0" />
    </filter>
  </defs>
  <image width="100%" height="100%" xlink:href="http://i.stack.imgur.com/OyP0g.jpg" filter="url(#colorMask3)" />
</svg>


La etiqueta img tiene una propiedad de fondo como cualquier otra. Si tienes un PNG blanco con una forma transparente, como una plantilla, entonces puedes hacer esto:

<img src= 'stencil.png' style= 'background-color: red'>

Para cambiar literalmente el color, puede incorporar una transición de CSS con un filtro -webkit donde, cuando ocurra algo, invoque el filtro -webkit de su elección. Por ejemplo:

img {
    -webkit-filter:grayscale(0%);
    transition: -webkit-filter .3s linear;
    }
img:hover 
    {
    -webkit-filter:grayscale(75%);
    }

Encontré este gran ejemplo de código que inserta su valor de color hexadecimal y devuelve el filtro necesario para aplicar este color a png

Generador de filtro CSS para convertir de negro a color hexadecimal objetivo

por ejemplo, necesitaba que mi png tuviera el siguiente color # 1a9790

entonces tienes que aplicar el siguiente filtro a ti png

filter: invert(48%) sepia(13%) saturate(3207%) hue-rotate(130deg) brightness(95%) contrast(80%);

La línea más simple que funcionó para mí:

filter: opacity(0.5) drop-shadow(0 0 0 blue);

Puede ajustar la opacidad de 0 a 1 para hacer que el color sea más claro o más oscuro.


La clase de capacitación de Android , " Visualización eficiente de java.lang.OutOfMemoryError: bitmap size exceeds VM budget bits ", ofrece información excelente para comprender y manejar la excepción java.lang.OutOfMemoryError: bitmap size exceeds VM budget cuando se cargan java.lang.OutOfMemoryError: bitmap size exceeds VM budget bits.

Leer dimensiones y tipo de mapa de bits

La clase BitmapFactory proporciona varios métodos de decodificación ( decodeByteArray() , decodeFile() , decodeResource() , etc.) para crear un Bitmap desde varias fuentes. Elija el método de decodificación más adecuado en función de su fuente de datos de imagen. Estos métodos intentan asignar memoria para el mapa de bits construido y, por lo tanto, pueden resultar fácilmente en una excepción OutOfMemory . Cada tipo de método de decodificación tiene firmas adicionales que le permiten especificar opciones de decodificación a través de la clase BitmapFactory.Options . Establecer la propiedad inJustDecodeBounds en true mientras se decodifica evita la asignación de memoria, devolviendo null para el objeto de mapa de bits pero configurando outWidth , outHeight y outMimeType . Esta técnica le permite leer las dimensiones y el tipo de los datos de imagen antes de la construcción (y asignación de memoria) del mapa de bits.

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(getResources(), R.id.myimage, options);
int imageHeight = options.outHeight;
int imageWidth = options.outWidth;
String imageType = options.outMimeType;

Para evitar las excepciones de java.lang.OutOfMemory , verifique las dimensiones de un mapa de bits antes de decodificarlo, a menos que confíe absolutamente en la fuente para proporcionarle datos de imagen de tamaño predecible que se adapten cómodamente a la memoria disponible.

Cargar una versión reducida en la memoria

Ahora que se conocen las dimensiones de la imagen, se pueden usar para decidir si la imagen completa se debe cargar en la memoria o si se debe cargar una versión de submuestreo. Aquí hay algunos factores a considerar:

  • Uso estimado de la memoria para cargar la imagen completa en la memoria.
  • La cantidad de memoria que está dispuesto a comprometerse a cargar esta imagen dado cualquier otro requisito de memoria de su aplicación.
  • Dimensiones del componente ImageView o UI de destino en el que se cargará la imagen.
  • Tamaño de pantalla y densidad del dispositivo actual.

Por ejemplo, no vale la pena cargar una imagen de 1024x768 píxeles en la memoria si finalmente se mostrará en una miniatura de 128x96 píxeles en un ImageView .

Para decirle al decodificador que muestree la imagen en una submuestra, cargando una versión más pequeña en la memoria, establezca inSampleSize en true en su objeto BitmapFactory.Options . Por ejemplo, una imagen con resolución 2048x1536 que se decodifica con un inSampleSize de 4 produce un mapa de bits de aproximadamente 512x384. Cargar esto en la memoria usa 0.75MB en lugar de 12MB para la imagen completa (asumiendo una configuración de mapa de bits de ARGB_8888 ). Aquí hay un método para calcular un valor de tamaño de muestra que es una potencia de dos en función de un ancho y una altura de destino:

public static int calculateInSampleSize(
        BitmapFactory.Options options, int reqWidth, int reqHeight) {
    // Raw height and width of image
    final int height = options.outHeight;
    final int width = options.outWidth;
    int inSampleSize = 1;

    if (height > reqHeight || width > reqWidth) {

        final int halfHeight = height / 2;
        final int halfWidth = width / 2;

        // Calculate the largest inSampleSize value that is a power of 2 and keeps both
        // height and width larger than the requested height and width.
        while ((halfHeight / inSampleSize) > reqHeight
                && (halfWidth / inSampleSize) > reqWidth) {
            inSampleSize *= 2;
        }
    }

    return inSampleSize;
}

Nota : Se calcula una potencia de dos valores porque el decodificador utiliza un valor final al redondear a la potencia más cercana de dos, según la documentación de inSampleSize .

Para usar este método, primero decodifique con inJustDecodeBounds establecido en true , pase las opciones y luego inSampleSize nuevamente usando el nuevo valor inJustDecodeBounds e inJustDecodeBounds establecido en false :

public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
    int reqWidth, int reqHeight) {

    // First decode with inJustDecodeBounds=true to check dimensions
    final BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeResource(res, resId, options);

    // Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

    // Decode bitmap with inSampleSize set
    options.inJustDecodeBounds = false;
    return BitmapFactory.decodeResource(res, resId, options);
}

Este método facilita la carga de un mapa de bits de tamaño arbitrariamente grande en un ImageView que muestra una miniatura de 100x100 píxeles, como se muestra en el siguiente código de ejemplo:

mImageView.setImageBitmap(
    decodeSampledBitmapFromResource(getResources(), R.id.myimage, 100, 100));

Puede seguir un proceso similar para decodificar mapas de bits de otras fuentes, sustituyendo el método apropiado BitmapFactory.decode* según sea necesario.





css image colors png overlay