O meu modelo mais recente, Dezasseis, está agora disponível no Ravelry.

Depois de um test knit sem percalços, este é capaz de ser o modelo que lancei mais rapidamente. Fiquei desapontada quando me apercebi que teria de o lançar só para um tamanho, mas acabei por decidir que valia a pena. O preço do modelo reflecte a falta de outros tamanhos no modelo.

Ainda assim espero que alguém desfrute do modelo na mesma.

E muito obrigada às testers do modelo! Podem ver as versões tricotadas no teste na tab Projects no Ravelry.

Podem saber mais sobre as meias aqui.

Já penso em escrever um blog post sobre como coser camisolas em tricô por peças há bastante tempo, e agora vem mesmo a calhar já que no teste do meu modelo novo há algumas pessoas a chegar a esta fase.

Não vou falar tanto das diferentes formas de coser uma peça à outra porque eu gosto de o fazer da forma mais simples, mantendo as orlas de duas peças paralelas e passando o fio de uma peça para outra de forma perpendicular com uma agulha de tapeçaria (uma espécie de pesponto ou backstitch). Há técnicas interessantes como mattress stitch e como costuras em crochet, entre outras, mas eu prefiro uma costura visível e simples de executar.

Na minha experiência, a parte mais complicada deste processo é coser as mangas à camisola e é nisso que me vou focar neste blog post.

• Passo 0: Bloquear as peças de forma a que fiquem com as medidas indicadas no modelo. Costumo bloquear colocando a camisola de molho em água e detergente para lãs (Eucalan ou Soak). No caso da minha camisola Argila é particularmente importante bloquear de acordo com as dimensões porque facilmente esticamos o ponto tijolo em excesso;

• Passo 1: Coser os ombros da peça da frente à peça de trás. Os ombros devem ter acabado com o mesmo número de malhas e por devem ser exactamente do mesmo tamanho;

• Passo 2: Coser a cabeça da manga à camisola:

  • 2.1: Identificar o ponto médio do topo da manga e juntar esse ponto à costura do ombro com um marcador;
  
  • 2.2: Juntar o ponto de início da cava da manga com o ponto correspondente de início da cava da parte da frente e repetir para o outro lado da manga e costas;
  
  • 2.3: Juntar o resto da manga à frente e costas de forma uniforme com marcadores;
  
  • 2.4: Começar a coser a manga à camisola começando no ponto médio que se encontrou no passo 2.1 e deixando um pedaço de fio com comprimento suficiente para coser o outro lado. Depois de terminar um lado da cabeça da manga, coser o outro lado.

• Passo 3: Juntar as orlas da manga com marcadores identificando os aumentos e o início da manga. Coser a manga;

• Passo 4: Repetir desde o passo 2 para a segunda manga;

• Passo 5: Juntar a frente às costas com marcadores identificando os aumentos e o início das peças. No caso da Argila, uma vez que a frente é em ponto tijolo e as costas são em ponto jersey, os aumentos não foram feitos ao mesmo ritmo, mas deverão estar exactamente no mesmo sítio em altura;

  

• Passo 6: Rematar as pontas e trabalhar uma gola se for caso disso!

Espero que ajude alguém e que não seja como aquele meme da coruja.

Este blog post é a continuação do post O puzzle de uma manta de retalhos: Parte 1.

De acordo com o plano delineado na Parte 1, agora restava atribuir uma cor a cada número utilizado na secção anterior.

O plano era utilizar um rolo do Robert Kaufman (mais sobre o rolo na Parte 1), e no site do produtor é possível ver fotos dos tecidos que vêm no conjunto. Obtive os valores RGB de cada cor, tirando um screenshot do site e utilizando o color pick do Gimp. Agora faltava dizer ao Racket quais as cores que queria utilizar.

Compilei a minha lista de cores:

(define c1 (make-color 246 246 248))
(define c2 (make-color 245 243 231))
(define c3 (make-color 246 246 236))

Fiz o mesmo para as 38 cores.

A colecção de cores que ia utilizar era esta:

Finalmente podia começar a pensar em triângulos. Com Racket pintar um triângulo é tão simples como:

;; draw a equilateral triangle, length 40, and paint it with color red
(triangle 40 "solid" "red")

Faltava apenas desenhar os triângulos e atribuir a cada triângulo a cor que estava presente no mesmo índice da matriz que obtivemos na Parte 1. Ao mesmo tempo, ia rodar cada triângulo 180°, triângulo sim triângulo não, e rodar os triângulos na carreira seguinte na ordem oposta.

;; list of colors defined by me
(define rangeofcolors (vector c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16
c17 c18 c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31 c32 c33 c34 c35 c36 c37
c38))

;; draw equilateral triangle, length 40, color x
(define (givecolor x)
  (triangle 40 "solid" x))
;; draw and rotate 180° equilateral triangle, length 40, color z
(define (givecolor180 z)
  (rotate 180 (triangle 40 "solid" z)))

;; get a matrix of 26 rows from Part 1
(define quilt (paint_n_rows 26))

;; paint triangles, but rotate them on [odd rows and even index of quilt]
;; and on [even rows and odd index of quilt]
(define (colorit anyquilt j i)
  (if (odd? j)
      (if (odd? i)
          (givecolor (vector-ref rangeofcolors (vector-ref (list-ref anyquilt j) i)))
          ;;else
          (givecolor180 (vector-ref rangeofcolors (vector-ref (list-ref anyquilt j) i))))
    ;;else
    (if (odd? i)
       (givecolor180 (vector-ref rangeofcolors (vector-ref (list-ref anyquilt j) i)))
       ;;else
       (givecolor (vector-ref rangeofcolors (vector-ref (list-ref anyquilt j) i))))))

;; save image (copied straight from stackoverflow ;))
(define (save-pict the-pict name kind)
  (define bm (pict->bitmap the-pict))
  (send bm save-file name kind))

;; bringing it all together
(define (print-all-pretty)
  ;;
  (let ([result (for/fold ([rows (blank)]) ([j (length quilt)])
     ;; draw a new picture with each row of triangles
     (vc-append
      (for/fold ([row2 (blank)]) ([i (vector-length (list-ref quilt j))])
        ;; draw a new picture of row of each triangle in the specified color
        ;; and remove white space between triangles
        (hc-append -20 (colorit quilt j i) row2))
      rows
      ))])
        (begin
          (print result)
          ;; crop image to remove half a triangle on the side edge and save it
          (save-pict (crop 20 0 880 1040 (pict->bitmap result)) "triangles.png" 'png)
        )))

O resultado final:

Adoro. Assim que vi o resultado final comprei o tecido.

Sinto que devo escrever alguma coisa em relação à minha experiência com Racket, mas uma vez que não tenho experiência nenhuma em programação, não dá para fazer comparações e a minha opinião não tem grande significado. Mas aqui vai: a sintaxe não foi difícil de compreender, mas às vezes perdia-me no meio de tantos parênteses. A documentação é bastante detalhada e se no futuro precisar de fazer algo do género, certamente que voltarei a fazê-lo com Racket. (O meu marido apaixonou-se pela linguagem.)

Em relação à manta de retalhos, vou ter de alterar o número máximo de triângulos e o número de cores porque, depois de receber o tecido no correio, percebi que tinha feito dois erros: primeiro, cada tira de tecido permite cortar apenas 27 triângulos (por causa das orlas do tecido); segundo, o rolo tem 4 cores extra para além das que são mostradas no site do produtor. Mas são alterações simples, nada dramático.

Conto com continuar a escrever actualizações, mas desta vez apenas em relação à manta, o que vai mais de encontro ao tema deste blog.

Já comecei a cortar os triângulos e consigo perceber que este projecto vai estar aqui para durar.

Este processo foi engraçado e espero que ajude alguém no futuro.

Antes de começar, devo avisar os leitores habituais deste blog que os próximos dois posts vão divergir completamente do que geralmente escrevo por aqui. Zero tricô!

Já tenho vontade de costurar uma manta de retalhos desde que comecei a costurar (falei disso no podcast várias vezes). Sempre gostei muito do modelo de manta de retalhos Little Peaks Quilt da Purl Soho, mas depois de ler as instruções do modelo percebi que este modelo não se adapta bem à minha personalidade, porque não há nenhum plano para a utilização dos tecidos. Dizem apenas para escolher “dois triângulos” ao acaso, sem planeamento de cores.

A amostra da Purl Soho é linda:

No entanto, eu quero utilizar tecidos com cores muito diferentes e é difícil para mim começar um projecto desta magnitude sem ter a certeza de que vou gostar do resultado final.

Enquanto andava a ponderar a questão da manta de retalhos, fui à procura de tecidos e descobri que existem rolos de tiras de tecidos pré-cortados com cores concordantes. Queria utilizar cores neutras e uma cor contrastante. Acabei por escolher um rolo Robert Kaufman Kona Neutrals Palette 2-1/2" Roll-Up e 1 "fat quarter" extra na cor Kumquat.

O plano era seguir as instruções do modelo mencionado mais acima, mas seguir o meu esquema de cores, que ao contrário do modelo não iria ter uma cor que é repetida triângulo sim triângulo não.

Ao utilizar o rolo de tecido, iria ter 37 cores e o cor de laranja do “fat quarter”. De cada tira de tecido conseguia cortar 31 triângulos equiláteros de comprimento 6.35cm; do “fat quarter” também conseguia cortar pelo menos 31 triângulos iguais. No total iria ter 38 x 31 = 1178 triângulos. Agora teria de determinar a localização de cada triângulo, que poderiam estar colocados ao acaso, excepto que 2 triângulos da mesma cor nunca poderiam estar ao lado um do outro, tanto à esquerda como à direita, e tanto na fila acima como na fila abaixo. Os vértices dos triângulos não me preocupavam, apenas os lados dos triângulos.

Ao ignorar os vértices, percebi que podia pensar em rectângulos em vez de triângulos e obter o mesmo resultado.

Os rectângulos simplificaram o problema e comecei a pensar em números em vez de cores. Podia procurar uma solução para números e atribuir uma cor a cada número mais tarde.

O próximo passo passou por determinar o comprimento e largura da manta de retalhos em termos de triângulos. Decidi que queria ter 22 triângulos de largura e 26 triângulos de altura, ou 139cm x 165cm (o resultado final vai ser sempre mais pequeno por causa margem de costura). Na verdade, as linhas horizontais de triângulos iriam utilizar o dobro dos triângulos que eu utilizei para determinar a largura da manta, e por isso iria utilizar 44 x 26 = 1144 triângulos no total.

Com esta informação o problema a resolver era este: organizar sequências de números de 1 a 38, numa matriz de [26 x 44], de forma a que cada número nunca seja repetido tanto para os lados como para as linhas acima e abaixo, e limitando a utilização de cada número a 31 vezes.

Desde o início senti que a forma mais rápida de resolver o problema seria com programação. O meu marido trabalha em informática e está sempre a tentar convencer-me a experimentar uma linguagem de programação que ele considera que me possa ser útil. Já me falou várias vezes de Racket particularmente porque facilmente se criam desenhos com esta linguagem de programação. Finalmente fui espreitar do que se tratava e a parte dos desenhos parecia ser bastante acessível (reparem nos desenhos bonitos que fiz mais acima). Mas antes de chegar à parte dos desenhos ainda tinha muito que fazer (tinha de comer muita sopa é o que me apetece escrever).

Para contextualizar a minha experiência com programação, tive uma cadeira de Introdução à Programação na faculdade onde trabalhámos com R e mais tarde participei num curso de Python no Coursera. Ou seja, não fazia ideia do que estava a fazer (e ainda não sei), mas tinha a sensação que um loop resolvia isto tudo. Claro que acabei por precisar muito da ajuda do meu marido, especialmente para ir de um vector para uma matriz. Nem o meu marido nem eu tínhamos qualquer experiência com Racket, por isso o código que escrevemos pode não estar escrito da forma mais idiomática.

(Estou com preguiça de traduzir os comentários 😓)

Preparativos:

;; dictionary that keeps track of the number of time a color was used
(define colors_count (make-hash))

;; maximum number of times a color can be used
(define MAX_COLOR_COUNT 31)

;; number of colors available 
(define MAX_COLORS 38) 

;; set all colors 1-38 to 31 available units on the dictionary
(for ([i MAX_COLORS]) 
(dict-set! colors_count i MAX_COLOR_COUNT))

;; start a vector 44 in length 
(define row (build-vector 44 values)) 

;; first non colored row
(define NO_COLOR -1)
(define dummy (build-vector 44 (lambda (x) NO_COLOR)))

Seleccionar as cores tendo em conta a condição imposta:

;; pick a random color that still has available units on the dictionary
(define (random_color) 
  (let ([color (random (dict-count colors_count))]) 
    (while #t
           (set! color (random (dict-count colors_count))) 
           (let ([color_count (hash-ref colors_count color)]) 
             (when (> color_count 0) 
                 (break))))
    color))

;; update the units available for each color 
(define (updatedictionary color) 
   (dict-set! colors_count color (- (hash-ref colors_count color) 1)))

;; true if c1 is different from c2 and c3
(define (differ c1 c2 c3) 
  (and (not (equal? c1 c2))
       (not (equal? c1 c3))))

;; select a color that is different from the previous selected color 
;; and different from the color on the same index on the row below
(define (selectcolor previous_color below_color) 
  (if (and (equal? previous_color NO_COLOR) (equal? below_color NO_COLOR))
      (begin
        (updatedictionary (random_color))
        (random_color))
      ;; else
      (begin
        ;;continue looking for a color until it finds one that is different
        ;;from the previous color and the color on the same index on the row below
        (let ([generated_color (random_color)])
          (while (not (differ generated_color previous_color below_color)) 
                 (set! generated_color (random_color)))
              (updatedictionary generated_color)
              generated_color
              ))))

Criar a matriz e imprimir o resultado:

;; fills a vector with colors provided by the selectcolor function, 
;; taking into account the colors on the row below 
(define (paint_row below_row)
  (let ([row (build-vector 44 values)])
    (for ([i (vector-length row)]) 
      (let ([below_color (vector-ref below_row i)])
        ;; for i=0, there isn't a previous color 
        (if (equal? i 0)
            (begin
              (vector-set! row i (selectcolor NO_COLOR below_color))
              (display (~r (vector-ref row i) #:min-width 2 #:pad-string "0"))
              (display " ")
              )
            ;; else
            ;; looks for the previous color on index i-1 of vector row, 
            ;; and selects a new color considering also the color below
            (begin
              (let ([previous_color (vector-ref row (- i 1))])
                (let ([picked_color (selectcolor previous_color below_color)]) 
                  (display (~r picked_color #:min-width 2 #:pad-string "0"))
                  (display " " )
                  (vector-set! row i picked_color)  
                  ))))))row))

;; paints n rows and prints the result 
(define (paint_n_rows n)
  (let ([result (list)]) 
    ;; paints the first row and appends it to the result list
  (let ([previous_row (paint_row dummy)]) 
    (set! result (append result (list previous_row)))
    (display "\n")
    ;; continues painting to n-1 and appends the results to the result list
    (for ([i (- n 1)]) 
      (begin
        (set! previous_row (paint_row previous_row)) 
        (set! result (append result (list previous_row)))
        (display "\n")
        )))
    result))

Ao ler o código e escrever os comentários apercebi-me que só escrevi talvez metade do código. Sem a ajuda do meu marido ainda aqui estava a tentar escrever isto.

Mas aqui estamos com o assunto resolvido, e para por exemplo (paint_n_rows 4) o resultado é este:

31 36 33 29 28 02 11 12 33 15 03 08 30 02 37 11 21 26 19 36 27 11 09 07 15 09 14 35 26 36 12 19 21 24 12 20 30 34 32 30 14 15 26 29

11 04 07 00 06 14 17 06 14 12 37 24 21 30 31 25 29 15 25 03 07 01 14 03 14 36 24 08 33 17 02 24 02 08 00 01 02 03 08 24 10 07 32 33

34 17 13 07 33 20 13 18 26 16 06 36 10 32 25 00 12 09 16 07 26 22 01 14 02 27 10 13 22 16 17 13 37 23 30 02 11 24 28 16 01 17 29 01

19 29 37 18 37 30 04 32 21 11 24 34 21 16 20 26 17 26 18 28 33 09 10 12 19 23 12 37 01 33 08 03 11 01 23 28 00 03 32 12 13 24 02 04

A parte difícil estava feita e podia finalmente começar a brincar com os triângulos.

Como este post está enorme, isto é a Parte 1. Vou continuar na Parte 2.