Distribuindo automaticamente páginas coloridas e preto-branco para a impressora correspondente
- Código-Fonte
  - colorpages.sh
  - alg.awk
- Funcionamento

Distribuindo automaticamente páginas coloridas e preto-branco para a impressora correspondente

Este script permite a distribuição de páginas coloridas de um documento a ser impresso numa impressora colorida e as página preto/branco na impressora correspondente. É necessária a instalação do ImageMajick, sed e awk.

Para executar:

colorpages.sh <arquivo> <tipo de impressão>

<arquivo>: Localização do arquivo a ser impresso
<tipo de impressão>:
- rascunho : Páginas coloridas consecutivas são impressas frente e verso. O mesmo ocorre para páginas preto e branco. Se uma página é preto e branco e a seguinte é colorida, elas são impressas em folhas separadas
- tese : Páginas consecutivas Ímpar/Par são impressas frente e verso. As páginas consecutivas coloridas serão impressas na impressora a cor e as preto e branco na respectiva impressora. Se uma página ímpar é preto e branco e a seguinte é colorida, serão, primeiramente impressas as páginas preto e branco. O usuário deve retirá-las e colocá-las em ordem dentro da impressora colorida. Recomendada quando a impressora colorida usa mistura de cores para gerar preto
- lazy : Semelhante a 'tese', mas o usuário não retira o restante da impressora PB. Aqui, as páginas Ímpar/Par que possuam um lado colorido e outro PB são impressas na impressora colorida. Se a impressora colorida possui toner próprio para preto, fica mais simples usar esta opção.

OBS: Não testei com arquivos que não estejam em formato PDF.

Código-Fonte

Dois arquivos são necessários: colorpages.sh e alg.awk.

colorpages.sh

#!/bin/bash

function colorpages {
 file="$1"
 i=0;
 j=0;
 for page in $(identify -format '%p ' "$file") ; do
  if [ -n "`convert "$file[$((page-1))]" -colorspace RGB -unique-colors txt:- | sed -e 1d | awk -f alg.awk | head -n 1`" ]
  then
   COLOR[i]=$page;
   i=$((i+1))     
  else
   BW[j]=$page;
   j=$((j+1))
  fi
 done
} 

function printArray {
  declare -a ARR=("${!1}")
  TAM=${#ARR[@]}
  for ((k=0;k<$((TAM-1));k++))
  do
    echo -n ${ARR[k]}","
  done
  if [ $TAM -gt 0 ]; then
    echo -n ${ARR[$((TAM-1))]}
  fi
}

function divideSingleDouble {
  declare -a ARR=("${!1}")
  ARR_DOUBLE=( )
  ARR_SINGLE=( )
  TAM=${#ARR[@]}
  declare -i ind=0
  declare -i ind2=0
  for ((k=0;k<$TAM;))
  do
    if [ "${ARR[$((k+1))]}" == $((${ARR[$k]}+1)) ];
    then
      ARR_DOUBLE[$ind1]=${ARR[$k]}
      ARR_DOUBLE[$((ind1+1))]=${ARR[$((k+1))]}
      ind1=$((ind1+2))
      k=$((k+2));
    else
      ARR_SINGLE[$ind2]=${ARR[$k]}
      ind2=$((ind2+1))
      k=$((k+1));
    fi
  done
}

function divideSingleDoubleOdd {
  declare -a ARR=("${!1}")
  ARR_DOUBLE=( )
  ARR_SINGLE=( )
  TAM=${#ARR[@]}
  declare -i ind=0
  declare -i ind2=0
  for ((k=0;k<$TAM;))
  do
    if [ $((${ARR[$k]} % 2)) == 1 -a "${ARR[$((k+1))]}" == $((${ARR[$k]}+1)) ];
    then
      ARR_DOUBLE[$ind1]=${ARR[$k]}
      ARR_DOUBLE[$((ind1+1))]=${ARR[$((k+1))]}
      ind1=$((ind1+2))
      k=$((k+2));
    else
      ARR_SINGLE[$ind2]=${ARR[$k]}
      ind2=$((ind2+1))
      k=$((k+1));
    fi
  done
}

function createCOLORandBWpages {
  divideSingleDouble COLOR[@]
  COLOR_DOUBLE=(${ARR_DOUBLE[@]})
  COLOR_SINGLE=(${ARR_SINGLE[@]})
  divideSingleDouble BW[@]
  BW_DOUBLE=(${ARR_DOUBLE[@]})
  BW_SINGLE=(${ARR_SINGLE[@]})
} 

function createCOLORandBWpagesOdd {
  divideSingleDoubleOdd COLOR[@]
  COLOR_DOUBLE=(${ARR_DOUBLE[@]})
  COLOR_SINGLE=(${ARR_SINGLE[@]})
  divideSingleDoubleOdd BW[@]
  BW_DOUBLE=(${ARR_DOUBLE[@]})
  BW_SINGLE=(${ARR_SINGLE[@]})
}

function printHelp {
  echo "colorpages.sh <arquivo> <tipo de impressão>"
  echo "  arquivo: Localização do arquivo a ser impresso"
  echo "  tipo de impressão: "
  echo "    - rascunho : Páginas coloridas consecutivas são impressas frente e verso"
  echo "                 O mesmo ocorre para páginas preto e branco. Se uma página é"
  echo "                 preto e branco e  a seguinte é colorida, elas são impressas"
  echo "                 em folhas separadas"
  echo "    - tese : Páginas consecutivas Ímpar/Par são impressas frente e verso.  As"
  echo "             páginas consecutivas  coloridas serão impressas  na impressora a"
  echo "             cor e as preto e branco na respectiva impressora. Se uma  página"
  echo "             ímpar é preto e branco e a seguinte é colorida, serão, primeira-"
  echo "             mente impressas as páginas  preto e branco. O usuário deve reti-"
  echo "             rá-las e colocá-las em ordem dentro da impressora colorida.  Re-"
  echo "             comendada quando a impressora colorida usa mistura de cores para"
  echo "             gerar preto"
  echo "    - lazy : Semelhante a 'tese', mas o  usuário não retira o restante da im-"
  echo "             pressora PB. Aqui, as páginas Ímpar/Par que possuam um lado  co-"
  echo "             lorido e outro PB são impressas na impressora colorida. Se a im-"
  echo "             pressora  colorida  possuir  toner próprio para preto, fica mais"
  echo "             simples usar esta opção."
} 

function testando {
  TAM=50
  declare -i ind1=0
  declare -i ind2=0
  for((k=1;k<=$TAM;k++))
  do
    if [ $RANDOM -lt $((32767*25/100)) ]
    then
      COLOR[$ind1]=$k;
      ind1=$((ind1+1));
    else
      BW[$ind2]=$k;
      ind2=$((ind2+1));
    fi
  done
} 

function mergeCOLORandBW_SINGLE {
  declare -a ARR1=(${COLOR[@]});
  declare -a ARR2=(${BW_SINGLE[@]});
  TAM1=${#ARR1[@]}
  TAM2=${#ARR2[@]}
  N=$((${#BW[@]}+${#COLOR[@]})); 

  # N pode ser par ou ímpar
  # Se for par, BW_SINGLE e COLOR terão tamanhos iguais
  # Se for ímpar, apenas um entre COLOR e BW_SINGLE
  # será ímpar. Se for BW_SINGLE, ele tem um elemento a mais
  # que COLOR.
  if [ $((N % 2)) == 1 -a $((TAM2 % 2)) == 1 ]; then
    BW_SINGLE=(${ARR2[$((TAM2-1))]})
  else
    BW_SINGLE=()
  fi 

  COLOR_DOUBLE=(); 

  #Aqui é semelhante ao Merge do Mergesort
  for ((k=0;k<TAM1;k++))
  do
    if [ "${ARR1[k]}" != "" -a "${ARR2[k]}" != "" ]; then
      if [ ${ARR1[k]} -lt ${ARR2[k]} ]; then
        COLOR_DOUBLE[$((k*2))]=${ARR1[k]}
        COLOR_DOUBLE[$((k*2+1))]=${ARR2[k]}
      else
        COLOR_DOUBLE[$((k*2))]=${ARR2[k]}
        COLOR_DOUBLE[$((k*2+1))]=${ARR1[k]}
      fi
    fi
  done 

  #se COLOR for maior que BW_SINGLE, adicionar o último a COLOR
  if [ $TAM2 -lt $TAM1 ]; then
    COLOR_DOUBLE[$((2*TAM1))]=${COLOR[$((TAM1-1))]}
  fi
  COLOR_SINGLE=();
} 

COLOR_PRINTER=matisse
BW_PRINTER=degas 

if [ "$1" == "" -o "$2" == "" ]; then
  printHelp;
  exit;
fi

colorpages $1

### Descomente abaixo para depuração ###
# testando; echo BW = ${BW[@]}; echo COLOR = ${COLOR[@]};  
###       Fim Depurapção             ###  

if [ $2 == "rascunho" ]; then
  createCOLORandBWpages;
elif [ $2 == "tese" ]; then
  createCOLORandBWpagesOdd;
elif [ $2 == "lazy" ]; then
  divideSingleDoubleOdd BW[@]
  BW_DOUBLE=(${ARR_DOUBLE[@]})
  BW_SINGLE=(${ARR_SINGLE[@]})
  mergeCOLORandBW_SINGLE;
else
  printHelp;
  exit;
fi

#Print Double Sided Color Pages 
if [ ${#COLOR_DOUBLE[@]} -gt 0 ]; then
  lpr -P $COLOR_PRINTER -o page-ranges=`printArray COLOR_DOUBLE[@]` -o Duplex=DuplexNoTumble $1;
fi 

#Print Double Sided BW Pages 
if [ ${#BW_DOUBLE[@]} -gt 0 ]; then
  lpr -P $BW_PRINTER -o page-ranges=`printArray BW_DOUBLE[@]` -o Duplex=DuplexNoTumble $1;
fi 

#Print Single Sided BW Pages
if [ ${#BW_SINGLE[@]} -gt 0 ]; then
  lpr -P $BW_PRINTER -o page-ranges=`printArray BW_SINGLE[@]` -o Duplex=None $1; 
fi 

if [ $2 == "rascunho" -o  $2 == "lazy" ]; then
  #Print Single Sided Color Pages
  if [ ${#COLOR_SINGLE[@]} -gt 0 ]; then
    lpr -P $COLOR_PRINTER -o page-ranges=`printArray COLOR_SINGLE[@]` -o Duplex=None $1;
  fi
elif [ $2 == "tese" ]; then
  #Print Single Sided Color Pages
  if [ ${#COLOR_SINGLE[@]} -gt 0 ]; then
    echo 
    echo "+-------------------------------------------------------------------------+"
    echo "| Coloque as páginas com verso em branco da impressora preto e branco (as |"
    echo "| últimas que saíram) na impressora colorida. Depois de colocadas, aperte |"
    echo "| ENTER para começar a impressão no verso delas.                          |"
    echo "+-------------------------------------------------------------------------+"
    read;
    lpr -P $COLOR_PRINTER -o page-ranges=`printArray COLOR_SINGLE[@]` -o Duplex=None $1;
  fi
else
  printHelp;
  exit;
fi

alg.awk

{
  match($0,/\(\ *[0-9]+,\ *[0-9]+,\ *[0-9]+\)/);
  STR=substr($0,RSTART+1,RLENGTH-2);
  split(STR, A,",")
  mean=(A[1]+A[2]+A[3])/3
  a_mean1 = A[1]-mean;
  a_mean2 = A[2]-mean;
  a_mean3 = A[3]-mean;
  value=sqrt(a_mean1*a_mean1 + a_mean2*a_mean2 + a_mean3*a_mean3);
  if (value > 653) {print $0}
}

Funcionamento

O script colorpages.sh possui dois array principais: BW e COLOR, a lista das páginas preto/branco e coloridas de um arquivo, respectivamente. As funções printBW e printCOLOR imprimem este vetores com seus elementos separados por vírgulas.

A função colorpages carrega o arquivo dado como argumento e preenche BW e COLOR com as páginas preto/branco e coloridas, respectivamente. Para cada página do arquivo PDF, ele lista todos os pixels únicos da página em formato RGB (usando convert do ImageMajick).

Os valores RGB são representados em valores de 0 a 65355. Para verificar se existe páginas coloridas, verifica-se se existe algum pixel cujos valores possuem desvio padrão maior que 653 (1% do valor máximo permitido). O código alg.awk realiza esta verificação.

Os vetores BW e COLOR a depender da opção fornecida pode ser dividido em dois vetores cada. BW é dividido em BW_DOUBLE, que possui pares de números consecutivos e BW_SINGLE, formado pelos números que sobraram, ordenados, de BW (ou seja, BW_SINGLE = BW - BW_DOUBLE). Similarmente ocorre com COLOR, COLOR_SINGLE e COLOR_DOUBLE.

Se a opção fornecida for tese ou lazy, os vetores _DOUBLE devem ser formados por duplas de números começados por números ímpares. Na opção rascunho, não é necessário. Isto ocorre porque em teses as folhas começam com números ímpares.

O código foi escrito de tal forma que no máximo quatro jobs sejam enviados para as duas impressoras. É fornecido a cada job as listas das páginas a serem impressas, a impressora correspondente e se é para ser impresso frente e verso ou um lado apenas.