Em um projeto no qual estou atualmente envolvido existe uma página de busca onde o cliente pode buscar pelo endereço (rua, estado, cidade, bairro...),  então havia a necessidade de gerar uma query apenas com os campos que forem preenchidos. Ex.: O cliente preenche apenas pela cidade logo eu devo trazer todos daquela cidade ignorando o bairro. Depois de "quebrar a cabeça" por um tempo cheguei a solução que foi detalhar abaixo:

Unindo a expressions

Temos abaixo as duas expressions com as duas consultas que desejamos unir para fazer apenas uma busca na base de dados:


Expression<Func<Endereco, bool>> expAntiga = p => (p.Cidade == "Caruaru");

Expression<Func<Endereco, bool>> expNova = p => (p.Bairro=="Petrópolis");

Na primeira é uma busca pela cidade e a busca deve considerar também o bairro.

Para fazer a junção eu crio uma nova expression e chamo o método AndAlso passando o paramêtro Body das expressions:

var expUnida = Expression.Lambda<Func<Endereco, bool>>(
                    Expression.AndAlso(expAntiga.Body, expNova.Body), expNova.Parameters);

Muito simples não é ?!

até a próxima ;)
Muito provavelmente você já teve ter percebido, principalmente se sua conexão não for das melhores, que ao abrir algumas Imagens do Facebook é carregado uma imagem em baixa resolução e depois de um tempo a imagem melhora, o Google também utiliza esse artifício na sua busca de imagem:


Como vamos fazer?

  1. Converter a imagem, ainda no servidor, em uma imagem de baixa resolução.
  2. Exibir essa imagem em baixa definição assim que a página for carregada.
  3. Fazer uma chamada Ajax para buscar a imagem em maior resolução.
  4. "Trocar" a imagem de baixa resolução, que está sendo exibida na tela, pela imagem de maior resolução.
Obter imagem em baixa resolução
private Image ObterImagemBaixaResolucao()
        {
            Image retorno = null;

            using (var image = ObterImagem())
            {
                retorno = image.GetThumbnailImage((image.Width / 16), (image.Height / 16), () => false, IntPtr.Zero);
            }

            return retorno;
        }

Assim obtemos a imagem em menor resolução, nesse caso 16x menor.
GetThumbnailImage é o método responsável por nos dar uma imagem em resolução menor.

Logo após eu converto a imagem em base 64:
public static string ImageToBase64(this Image image,ImageFormat format)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                image.Save(ms, format);
                byte[] imageBytes = ms.ToArray();

                return Convert.ToBase64String(imageBytes);
            }
        }

Quem tiver alguma dúvida sobre base 64 sugiro que dê uma lida aqui: http://inchoo.net/ecommerce/magento/what-is-base64-encoding-and-how-can-we-benefit-from-it/

E exibo na View:

<img id="imageCarregar" src="data:image/jpg;base64,@Model.ImagemBase64" />

Obter a imagem em resolução maior

Uma chamada Ajax busca a imagem em maior resolução:
function obterImagemAltaResolucao() {

            $.ajax({
                type: "POST",
                url: "/Home/ObterImagemResolucaoNormal",
                success: function (base64Data) {
                    $('#imageCarregar').attr('src', "data:image/jpg;base64," + base64Data);
                },
                error: function (xhr) {
                    alert("Occoreu um erro ao carregar a imagem. " + xhr.responseText);
                }
            });
        } 
Coloque a função JavaScript para executar assim que a página estiver carregada:
$(document).ready(function () {
            obterImagemAltaResolucao();
        });
Essa função carrega a imagem assincronicamente a quando termina substitui a imagem de baixa definição pela imagem retornada.


Essa é o método no controller responsável por retornar a imagem:
[HttpPost]
        public string ObterImagemResolucaoNormal()
        {
            var imageBase64 = String.Empty;

            using (Image image = ObterImagem())
            {
                using (Image newImage = new Bitmap(image))
                {
                    imageBase64 = newImage.ImageToBase64(ImageFormat.Jpeg);
                }
            }

            return imageBase64;
        }
O código pode ser baixado aqui: https://github.com/rafaelguinho/ProgressiveLoadImage
Esse é um recurso pouco conhecido de Java, eu particularmente admito que conheci a pouco tempo.
Para entendermos melhor vou dar um exemplo de um método que faça a soma de valores inteiros mas para dificultar digamos que esse método pode receber um número indefinido de parâmetros, acredito que vem logo em mente vamos utilizar um array a somar os valores:


 Isso não é errado, de forma alguma, mas não é muito prático para quem vai utilizar, já que o mesmo vai ter que criar um array popular os valores...

  Como melhoro isso!?

 Um dos novos recursos disponibilizados a partir do Java 1.5, permite criar métodos que recebem um número variável de argumentos. Um tipo de parâmetro seguido por reticências(...) na lista de parâmetros indica que o método recebe um número variável de argumentos desse tipo particular:


  E para utilizar é facil?

Muito fácil, basta preencher os parâmetros no método separados por vírgula, quantos forem necessário:
  int resultado = Somar(10,56,79);

Regras

Só para constar esses parâmetros só devem constar uma vez em cada método e deve sempre ser o último. Até mais!
Com a biblioteca OpenCv possível fazer bastante coisa, o foco desse post é a detecção facial. Para quer tiver interessado em conhecer um pouco mais: http://opencv.org/

Vamos utilizar Java que é umas das linguagens suportadas. Como vamos brincar com essa biblioteca iremos construir um aplicativo para desfocar apenas os rotos das pessoas em fotos:


"Chaves de menor":

Atenção, Creuzebek!

Faça do download da biblioteca no site do OpenCv: http://opencv.org/. Crie um projeto Java no Eclipse.

Clique com o potão direito sobre o seu projeto vá em: Build Path -> Configure Build Path,
espanda o item referente a JRE clique em edit e selecione o diretório
onde estão as bibliotecas nativas do OpenCv que por padrão estão em C:/opencv/opencv/build/java/x86,
mas pode mudar dependendo da sua instalação.



Nesse projeto eu utilizei os conceitos do SOLID, que bem resumidamente diz que cada classe deve servir a um único propósito. Dessa forma essa ficou sendo a minha estrutura de pacotes:



Para começar coloque a linha a seguir no main do seu código antes de qualquer outro trecho:

  
public static void main(String[] args) {
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
Essa linha é responsável por "invocar" as bibliotecas nativas que inserimos anteriormente, que na realidade é quem faz todo o trabalho. Logo após você precisará carregar um arquivo xml que contém as parametrizações necessárias para fazer o reconhecimento dos rostos:

CascadeClassifier cascadeClassifier = new CascadeClassifier(System.getProperty("user.dir") + "/haarcascade_frontalface_alt_tree.xml");

Bom aí você me pergunta onde encontro esse arquivo? dependendo da sua instalação ele fica arqui: C:\opencv\opencv\sources\data\haarcascades . Sugiro que você copie esse arquivo para raiz do seu projeto e carregue ele como está acima.
Após isso precisamos carregar a imagem, você deve fazer dessa forma:

Mat mat = Highgui.imread(System.getProperty("user.dir") +"/chaves.jpg");

No método imread você passa o caminho até o arquivo.

Para facilitar o entendimento eu crie um diagrama de atividades que ilustra os passos necessários para a brincadeira acontecer:



Passo 1 - Detectar faces

Para essa atividade ou passo está na classe ServiceDeteccaoFacesImagem e temo o método que faz a detecção das faces:

public MatOfRect detectarFaces(CascadeClassifier cascadeClassifier, Mat mat){
MatOfRect matOfRect = new MatOfRect();
cascadeClassifier.detectMultiScale(mat, matOfRect);
return matOfRect;
}

Esse método recebe os dois objeto criados anteriormente, que são respectivamente: a classe que "carrega" o xml e a classe que "carrega" a imagem. o objeto CascadeClassifier contém o método detectMultScale que localiza o que está sendo procurado na imagem que em nosso caso são rostos.

Passo 2 - Obter dados das faces

Os dados que serão obtidos das faces serão sua posição (x,y) na imagem e a largura e altura da face. O método a seguir contém a lógica de extração desses dados novamente a classe utilizada é ServiceDeteccaoFacesImagem:

public List obterDadosFaces(MatOfRect matOfRect){
  
  List dados = new ArrayList();
  
  for (Rect rect : matOfRect.toArray()) {
   
   PropriedadesFace prop = new PropriedadesFace();
   prop.setX(rect.x);
   prop.setY(rect.y);
   prop.setHeight(rect.height);
   prop.setWidth(rect.width);
   
   dados.add(prop);

  }
  
  return dados;
 }


Notem que o retorno é uma lista do objeto PropriedadesFace abaixo o modelo da classe desse objeto, ocultado os geters e seteres:

public class PropriedadesFace {
 private int x;
 private int y;
 private int width;
 private int height;
 private BufferedImage imageCortada;
Passo 3 - Desfocar toda a imagem

Vamos desfocar a imagem antes de "recortar" as faces, essa atividade está na classe ServiceDesfoqueImagem:

public BufferedImage DesfocarImagem(Mat mat){
  
  mat = Desfocar(mat);
  
  return Util.converterParaImage(mat);
 }
 
 private Mat Desfocar(Mat image){
         
  Mat destination = new Mat(image.rows(),image.cols(),image.type());
         
  Imgproc.GaussianBlur(image, destination,new Size(45,45), 0);
  
  return destination;
 }
 

Temos aqui esses 2 métodos um recebe o objeto Mat e o outro faz o desfoque da imagem. O desfoque é feito utilizado o método GaussianBlur da classe Imgproc, que pode ser invocado diretamente porque é um método estático. Por fim convertemos o objeto Mat para o BufferedImage, esse método se encontra na classe Util:

public static BufferedImage converterParaImage(Mat image){

  MatOfByte bytemat = new MatOfByte();

  Highgui.imencode(".jpg", image, bytemat);

  byte[] bytes = bytemat.toArray();

  InputStream in = new ByteArrayInputStream(bytes);

  BufferedImage img=null;

  try {
   img = ImageIO.read(in);
  } catch (IOException e) {
   e.printStackTrace();
  }

  return img;
 }

Passo 4 - Recortar as faces da imagem

Para cortar as faces da imagem utilizamos o método CortarImagem da classe ServiceCorteImagem:

public List CortarImagem(List dados, BufferedImage imagem){
  
  for(PropriedadesFace dado : dados){
   dado.setImageCortada(imagem.getSubimage(dado.getX(), dado.getY(), dado.getWidth(), dado.getHeight()));
  }
  
  return dados;
 }

Utilizamos o método getSubImage para "cortar" uma determinada parte da imagem e a imagem "cortada" é incluída no objeto PropriedadesFace, o mesmo objeto que contém seus dados.

Passo 5 - Obter imagem sem o desfoque

Para obter essa imagem utilizamos o método converterParaImagem na classe Util:

public static BufferedImage converterParaImage(Mat image){

  MatOfByte bytemat = new MatOfByte();

  Highgui.imencode(".jpg", image, bytemat);

  byte[] bytes = bytemat.toArray();

  InputStream in = new ByteArrayInputStream(bytes);

  BufferedImage img=null;

  try {
   img = ImageIO.read(in);
  } catch (IOException e) {
   e.printStackTrace();
  }

  return img;
 }

Essa imagem vai servir como fundo para "colarmos" as imagens dos rostos desfocados sobre ela.

Passo 6 -  Juntar imagem com as faces recortadas

Utilizamos esse dois métodos para sobrepor as imagens:

public BufferedImage juntarImagens(List dados, BufferedImage imagemPrincipal){
  
  for(PropriedadesFace dado: dados){
   imagemPrincipal = juntarUmaImage(imagemPrincipal, dado.getImageCortada(),dado.getX(),dado.getY());
  }
  
  return imagemPrincipal;
  
 }
 
 public static BufferedImage juntarUmaImage(BufferedImage imagemPrincipal,
            BufferedImage imagemCortada, int x, int y) {
 
        Graphics2D g = imagemPrincipal.createGraphics();
        
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                RenderingHints.VALUE_ANTIALIAS_ON);
        
        g.drawImage(imagemPrincipal, 0,0, null);
 
        g.drawImage(imagemCortada, x, y, null);
 
        g.dispose();
        return imagemPrincipal;
    }

O primeiro percorre todas as imagens que estão juntas com os dados das suas posições, já o segundo faz a sobreposição em si. Os dois métodos estão na classe ServiceSobreposicaoImagem.

Para terminar

Esse é o código do método main responsável por sequenciar as chamadas dos métodos:

System.loadLibrary(Core.NATIVE_LIBRARY_NAME);

  CascadeClassifier cascadeClassifier = new CascadeClassifier(System.getProperty("user.dir") + "/haarcascade_frontalface_alt_tree.xml");

  Mat mat = Highgui.imread(System.getProperty("user.dir") +"/chaves.jpg");
  
  ServiceDeteccaoFacesImagem serviceExtractFaces = new ServiceDeteccaoFacesImagem();
  MatOfRect matOfRect = serviceExtractFaces.detectarFaces(cascadeClassifier, mat);
  
  List propsFaces = serviceExtractFaces.obterDadosFaces(matOfRect);
  
  ServiceDesfoqueImagem serviceBlur = new ServiceDesfoqueImagem();
  BufferedImage imagemCorteDesfoque = serviceBlur.DesfocarImagem(mat);
  
  ServiceCorteImagem serviceCrop = new ServiceCorteImagem();
  propsFaces = serviceCrop.CortarImagem(propsFaces, imagemCorteDesfoque);
  
  ServiceSobreposicaoImagem serviceOverlay = new ServiceSobreposicaoImagem();
  
  BufferedImage imagemSemEfeitos = Util.converterParaImage(mat);
  
  imagemCorteDesfoque = serviceOverlay.juntarImagens(propsFaces, imagemSemEfeitos);
  
  File outputfile = new File("chaves menor.jpg");
  
     try {
   ImageIO.write(imagemCorteDesfoque, "jpg", outputfile);
  } catch (IOException e) {
   e.printStackTrace();
  }

E é isso galera quem quiser o código ele pode ser acessado aqui: https://github.com/rafaelguinho/HidingHerFace
É uma necessidade recorrente de todos que divulgam seus códigos em seus sites ou blogs. Pesquise bastante e encontrei algumas ferramentas para Syntax Highlighting, que nada mais é que "colorir o código" ficando da mesma forma que na IDE. Apesar de ter achado várias ferramentas uma delas me chamou atenção pela simplicidade.

Apresentando o SHJS - Syntax Highlighting in JavaScript

O SHJS utiliza JavaScript para "colorir" trechos do código, estando disponível para várias linguagens e tendo temas de várias IDEs conhecidas, entre elas o Eclipse e o Devcpp.

Vamos começar a brincadeira!

Preparei um exemplo em Java, minha linguagem preferida por sinal ;-) , com o bom e velho hello world:


Como você pode observar o Elipse colore as palavras chave do seu código para facilitar a leitura, eu sei que você já sabe disso...

De cara quando vemos um código com essas cores já pressupomos que é Java e isso até gera uma empatia do leitor com o site.

Agora vamos começar de verdade, juro!

Acesse a página do projeto na área de downloads: http://shjs.sourceforge.net/doc/download.html.
Baixe os arquivos marcados abaixo:

Logo após entre no link: http://shjs.sourceforge.net/lang/ e baixe o arquivo sh_java.js 
que é o arquivo correspondente a linguagem java, se você observar tem vários lá de muitas linguagens.

Para utilizar faça a importação dos arquivos baixados no seu html, crie uma tag pre definindo a class sh_java
e no body defina o atributo onload para "invocar" a função sh_highlightDocument();
como exemplo abaixo:


O resultado será semelhante a esse abaixo:


Tá bom mas ainda não é o que queremos. O que queremos é que fique da mesma forma que no eclipse. Para temos acesso ao tema do eclipse vamos baixar o projeto, vá no link download a source distribution:


Depois de baixar vá até a pasta css e pegue o arquivo sh_ide-eclipse.css e substitua onde está referenciando o arquivo sh_style.css.

Casa de ferreiro...

Mas daí eu fiz o post sobre a ferramenta e eu mesmo não utilizo!? Calma aí com companheiro! A partir de agora todos os códigos do meu blog vão utilizar essa ferramenta e pra provar o que digo selecione o Código Abaixo:
  public class HelloWorld {

   /**
    * @param args
    */
   public static void main(String[] args) {
    System.out.print("Olá, eu S2 programar!");
   }

  }

Abraço e até a próxima.
It is a recurring problem, you make an update in a system, and suddenly half the customers have problems with the update and everything is solved with a simple cache clearing. This occurs when a change involves a script, browsers keep a cache of scripts in order to speed up the loading of pages.

Simple solution

To resolve we will not clear the browser cache but do it download the file.

This is how it is usually inserted a script on the page:

<script src="meu_script.js"></script>

Just what we need to do is include a querystring in the src tag:

<script src="meu_script.js?v=2"></script>

Ie every time you change this number the browser will understand that this file is different than what he already has and does not need to clear the cache.

I especially love when the solution is simple :)

É um problema recorrente, você faz uma atualização, em um sistema, e de repente metade dos clientes tem problemas com a atualização e tudo é resolvido com uma simples limpeza de cache.  Isso ocorre quando alguma mudança envolve um script, os browsers guardam o cache dos scripts afim de agilizar o carregamento das páginas.

Solução simples

Para resolver não vamos limpar o cache do browser mas faze-lo baixar o arquivo.

É dessa forma que geralmente é inserido um script na página:

<script src="meu_script.js"></script>

Só o que precisamos fazer é incluir uma querystring no src da tag:

<script src="meu_script.js?v=2"></script>

Ou seja a cada vez que você mudar esse número o browser vai entender que esse arquivo é diferente do que ele já tem, não necessitando limpar o cache.

Eu particularmente adoro quando a solução é simples :)