Rotinas AutoLISP

John McCarthy - Faleceu o pai do LISP

2011-10-28T12:00:00.001+01:00

Para quem trabalha com a popular ferramenta de desenho, o AutoCad, sabe a importância que a linguagem AutoLisp representa na personalização e optimização, já que a partir dela é possível criar rotinas que acrescentam novas funcionalidades e ferramentas, desde as mais básicas até às mais complexas.
O AutoLisp foi desenvolvido especificamente para o AutoCad a partir da linguagem de programação LISP.
Serve este preâmbulo para dar a notícia de que o criador do LISP e da sua aplicação na Inteligência Artificial, John McCarthy, faleceu em 23 deste mês, com 84 anos. Obrigado pelo seu legado!

Exemplo de uma simples rotina para AutoCad desenvolvida em AutoLisp.

;;rotina que permite alterar o tamanho das entidades texto

;;comando: atxt

(defun c:atxt (/ a ht n i b1 b c d b2)
(prompt "\nA ALTURA DO TEXTO SERÁ MODIFICADA")
(setvar "cmdecho" 0)
(setq a (ssget))
(setq ht (getdist "\nINTRODUZA NOVA ALTURA"))
(setq n (sslength a))
(setq i 0)
(repeat n
        (setq b1 (entget (ssname a i)))
        (setq i (1+ i))
        (setq c (assoc 40 b1))
        (setq d (cons (car c) ht))
        (setq b2 (subst d c b1))
        (entmod b2)
)

(princ)
)

;;end code

A notícia: Link

Fonte: Teknomatika

ZPTEXT.lsp - Rotina AutoLISP

2011-06-30T16:54:00.000+01:00

Descrição: Esta rotina permite a selecção de entidades de texto numérico e desenhar entidades pontos elevadas na cota Z correspondentes ao valor do respectivo texto. Simultaneamente cria as correspondentes anotações de texto também elevadas no seu valor. Tantos os pontos criados como as anotações correspondentes são encaminhadas para layers próprias criadas automaticamente. Esta rotina mostra-se deveras útil para operações de transformação de topografia de 2D para 3D.

Description: This routine allows the selection of entities from text andnumeric entities draw high points in the Z coordinate corresponding to the value of the text. At the same time creates the corresponding text annotations also high in value. Both the points raised as the notes are forwarded to corresponding layers themselves automatically created.This routine appears to be very useful for operations transformationfrom 2D to 3D topography.

Comando: ZPTEXT

;;
;;rotina desenvolvida por Rotinas AutoLIsp - 2008
(defun c:zptext ()
(setvar "CMDECHO" 0)
(setvar "FLATLAND" 0)
(setvar "OSMODE" 0)
(setvar "ORTHOMODE" 0)
(setvar "PLINETYPE" 2)
(setvar "AUPREC" 0)
(setvar "PDMODE" 3)
(setvar "PDSIZE" 0.15)
(command "layer" "make" "3d-pontos" "color" "1" "" "")
(command "layer" "make" "3d-altimetria" "color" "103" "" "")
(setq f_pt (open "c:\\coordenadastxt.tmp" "w"))
;;cria um ficheiro temporário no disco C:
(vl-load-com)
(setq    *modelspace*
     (vla-get-modelspace
       (vla-get-activedocument (vlax-get-acad-object))
     )
)
(princ "\n<P>Seleccionar o texto a transformar em 3D: <E>Select Text:")
;;seleccionar os textos a transformar
(setq txt1 (ssget '((0 . "text"))))
(if (= txt1 nil)
    (close f_pt)
)
(setq txt2 (sslength txt1))
(setq counter 0);;contador
(while (< counter txt2)
    (progn
      (setq txtent (entget (ssname txt1 counter)))
      (setq cotax (car (cdr (assoc 10 txtent))))
;;extrai coordena x
      (setq cotay (cadr (cdr (assoc 10 txtent))))
;;extrai coordenada y
      (setq cotaz (atof (cdr (assoc 1 txtent))))
;;extrai coordenada z
      (setq xyz (list cotax cotay cotaz))
;;define a coordenada xyz de cada ponto a alterar
      (command "layer" "set" "3d-pontos" "")
;;passa para layer corrente
      (command "point" xyz)
;; insere o ponto na elevação correspondente à anotação
      (command "layer" "set" "3d-altimetria" "")
;;passa para layer corrente
      (command "text" xyz 0.20 0 (rtos cotaz 2 2))
;;escreve as anotações com a respectiva elevação do ponto
    )
    (setq counter (1+ counter))
;;incrementa o valor 1 à variável do contador
)
;;;
(command "zoom" "e")
(command "layer" "set" "0" "")
;;retoma como corrente a layer zero
(princ)
)
;;

- Como instalar a rotina

Curvas de Nível - Topografia

2010-12-14T17:32:00.001Z

(clicar para ampliar)

Curvas de nível:

Em topografia, o relevo de um terreno ou território é representado graficamente (mapas ou plantas topográficas) por linhas denominadas de curvas-de-nível.
As curvas-de-nível são linhas imaginárias em que cada uma em si representa uma porção de terreno com uma intercepção de pontos ou cotas à mesma altitude.
As curvas-de-nível no plano horizontal podem ser representadas em distâncias diferenciadas, sendo que um menor espaçamento significa um maior declive ou inclinação do terreno e um maior espaçamento significa menor declive.
No plano vertical, a representação das curvas-de-nível obedecerá a afastamentos equidistantes, sendo que as equidistâncias podem ser variáveis de mapa para mapa, normalmente em função da escala representada. Num mapa referente a pequenas parcelas, as equidistâncias podem representar valores de 1m ou até valores inferiores de acordo com o pormenor de leitura pretendido. Pelo contrário, em mapas mais abrangentes, representando grandes extensões de território, as equidistâncias podem equivaler a 5 metros ou valores bem superiores.

Graficamente, as curvas são anotadas com os valores da altitude/altimetria a que correspondem. Um perfil vertical resulta da projecção de linhas verticais no comprimento a que se referem os pontos das curvas interceptadas por uma linha recta no plano horizontal (ver figura acima).

As curvas-de-nível têm algumas propriedades intrínsecas que as caracterizam e definem, nomeadamente:
1 - Todos os pontos num terreno interceptados por uma curva-de-nível têm a mesma altitude;
2 - Uma curva-de-nível não pode derivar ou bi-furcar para outras curvas;
3 - As cruvas-de-nível nunca se podem cruzar ou interceptar.
4 - As curvas-de-nível fecham-se em si próprias, sendo que graficamente pode não ser possível representar essa realidade por insuficiência do tamanho do suporte na sua representação.

Ga.lsp – Rotina para obter áreas

2010-12-09T12:16:00.001Z

Excelente rotina de jefferypsanders.com, que permite obter as áreas de polígonos fechados, introduzindo automaticamente a respectiva anotação.

A rotina obtém e introduz também o valor do perímetro do polígono. No nosso caso, porque consideramos este segundo valor como irrelevante para as nossas necessidades, editamos o código da rotina de modo a introduzir apenas a área.

- Rotina original: Link

Comando: Ga

- Rotina alterada: Link

Comando: GAA

NOta: Para adequar o tamanho do texto, primeiramente deve ser alterado o valor correspondete da variável de sistema “textsize”.

Excellent jefferypsanders.com routine, giving areas of closed polygons, automatically introducing their annotation.

The routine gets the value and also introduces the perimeter of the
polygon. In our case, because we consider this second value as irrelevant to our needs, we edited the code of the routine in order to enter the area only.

- Google Translate

Topocal – Programa de topografia

2010-12-09T11:50:00.001Z

Para todos quantos trabalham na área de topografia, indispensável nas componentes de arquitectura e engenharia civil, existe um excelente programa, o TOPOCAL, com origem no Chile, supostamente em fase de desenvolvimento e que por isso tem sido disponibilizado de forma completamente gratuita, bastando um simples registo para ter acesso à chave de activação.
Nesta fase, que já dura há bastante tempo (2002), as contrapartidas exigidas nem são obrigatórias mas passam pela participação no desenvolvimento do programa, com contributos na forma de ideias e sugestões para melhoria do mesmo.

É verdade que para quem já está habituado a trabalhar com programas profissionais, quase sempre bastante caros, encontra algumas limitações neste TOPOCAL, desde logo a impossibilidade de recepção directa dos dados de um aparelho de levantamento topográfico, bem como outras ferramentas avançadas.
Todavia, para quem não faz da topografia a sua principal actividade, o TOPOCAL é uma excelente opção a considerar e, como no nosso caso particular, resulta muito bem como uma ferramenta complementar a trabalhos no conhecido AutoCad.

Apesar da tal impossibilidade de receber directamente os dados dos aparelhos de levantamento topográfico, tem no entanto várias opções de importação, lendo ficheiros no formato DXF, também utilizado pelo AutoCad, como lê ficheiros de pontos no formato ASCII com dados em diferentes separadores. Do mesmo modo, permite exportar o trabalho para o formato DXF, tanto em 2D como em 3D para além dos formatos nativos.

O programa TOPOCAL mostra-se muito eficiente nas principais tarefas e funções de cálculos topográficos, desde logo a criação de modelos de terreno digital, MDT, com triangulações e criação de curvas de nível, com diversos parâmetros de edição associados. Possui várias ferramentas de edição de pontos, curvas, polilinhas, etç.
É também muito bom a gerar secções, malhas, radiações, interpolações, etç.
O desempenho gráfico no manuseamento do desenho, incluindo zoom e vista em 3D é muito eficiente.
Permite também trabalhar com camadas (layers ou capas), possibilitando um controlo ideal das várias entidades.
Em suma, a este nível de software grátis, sem limitações de uso ou edição, não conhecemos na área da topografia programa semelhante com tão excelente qualidade, estabilidade e funcionalidade.

Tudo indica que o programa num futuro próximo, depois de terminada a fase de desenvolvimento por que tem passado, venha a ter custos associados à sua utilização pelo que importa aproveitar enquanto está disponível.
Para além de tudo, o sítio oficial disponibiliza um bom manual, se bem que em espanhol.

Actualmente a versão 2.0.48 ainda continua a ser gratuita mas já existe uma nova versão, a 3.0.79, que continua livre até 80% das funcionalidades sendo que para activar os restantes 20% requer um donativo no valor de 30 euros.

Aliás, percebia-se pelo desenvolvimento, que este software acabará por ter que ser pago na totalidade, certamente numa versão final, o que de resto é compreensível. Por conseguinte, não deixa de ser uma política interessante que um programa na sua fase de desenvolvimento deseja disponibilizado de forma gratuita, colhendo a colaboração dos utilizadores, reportando estes os erros, bugs, e sugerindo correcções e funcionalidades.

Esta tem sido a filosofia e abordagem do Topocal e creio que com sucesso.

[Sítio]

[Download da versão 2.0.48]

[Manual – Versão Chile]

[Manual – Versão Guatemala]

- Fonte: Teknomátika

http://www.topocal.com/joomla/index.php

Calendp.lsp – Desenhar calendário no AutoCad

2010-07-01T16:10:00.001+01:00

CALENDP.LSP, é uma interessante rotina que permite de forma automática desenhar um calendário no AutoCad.

A versão original em inglês foi adaptada para o português, nomeadamente quanto à nomenclatura dos dias e meses. No caso de se pretender novamente em inglês basta editar o código nas seguintes listas:

   (setq months
      (list
         "Janeiro"
         "Fevereiro"
         "Março"
         "Abril"
         "Maio"
         "Junho"
         "Julho"
         "Agosto"
         "Setembro"
         "Outubro"
         "Novembro"
         "Dezembro"
      )
   )

   (setq days
      (list
         "Domingo"
         "Segunda"
         "Terça"
         "Quarta"
         "Quinta"
         "Sexta"
         "Sábado"
      )

Funcionamento: Depois de se efectuar o download do código e de se gravar o ficheiro no formato .lsp, deve proceder-se ao carregamento. Depois de efectuado o load, chama-se o comando CALENDP. É solicitado o ano que se pretende, os dois pontos (corners) que vão definir o polígono de desenho, o número do mês pretendido (1-12) (por exemplo 4 para Abril), ou todos na opção All. Depois é solicitado o Nº de colunas e o espaçamento entre colunas e entre linhas. E é tudo. Nada mais simples.

[Download do código]

[Como carregar a rotina]

Ptt.lsp – Obter coordenadas x,y,z de entidades “points”

2010-06-02T17:58:00.001+01:00

Para quem trabalha em topografia, como é o nosso caso, por vezes torna-se necessário obter um ficheiro de texto com as coordenadas X,Y,Z das entidades pontos - "points" -.
Ora fazer isso de forma individual ou manual poderia representar um trabalho enorme e quase impraticável, dependendo da quantidade de pontos a considerar.
De modo a automatizar esta tarefa, desenvolvemos uma simples mas eficaz rotina que permite de forma rápida e automática captar as respectivas coordenadas e gerar um ficheiro no formato .txt.
A rotina, uma vez carregada pode ser chamada com a função ou comendo "PTT". De seguida é pedido ao utilizador que defina o nome do ficheiro a gerar e que será criado na raíz, na pasta C:
De seguida é pedido ao utilizador que escolha o separador das diferentes coordenadas, podendo escolher-se entre a vírgula e ponto-e-vírgula. É claro que até poderá escolher outro símbolo mas habitualmente são esses separadores os utilizados em ficheiros de topografia.
Finalmente, basta seleccionar os pontos dos quais se pretende obter as coordenadas. Nada mais simples.
Nos diversos testes efectuados, a rotina mostra-se fiável e com bons resultados. As coordenadas são geradas com 4 casas decimais. Ocasionalmente pode ocorrer gerar coordenadas com um número diferente de casas decimais, no caso sendo suprimidos os zeros à direita, o que provoca um desalinhamento na ordenação dos diferentes valores no ficheiro. Nestes casos recomenda-se que se volte a repetir o processo. Será também conveniente que as entidades "points" a seleccionar estejam limpas de quaisquer outras entidades.

For those working in topography, as is our case, sometimes becomes necessary to obtain a text file, with the coordinates X, Y, Z points of the entities - "points" -.
Now do this individually or manual labor could pose a huge and almost impossible, depending on the amount of points to consider.
In order to automate the task, we developed a simple but effective routine that allows to quickly and automatically capture their coordinates and generate a file in the. Txt.
The routine, once loaded can be called with the function or eating "PTT". Then the user is prompted to define the file name to generate and that will be created at the root, in the C:
Then the user is prompted to select the tab of the different coordinates, choosing among the comma and point-and-comma. Of course, until you can select another symbol but usually these separators are used in the files of topography.
Finally, simply select the points to which you want to get the coordinates. Nothing simpler.
In several tests, routine proves reliable and with good results. The coordinates are generated with four decimal places. May occur occasionally generate coordinated with a different number of decimal places, in the case being suppressed trailing zeroes, causing a misalignment in the order of the different values in the file. In these cases it is recommended that attention back to repeat the process. Be seen also that the entities "points" to be selected are clean of any other entities.

[Download]

[ Como carregar a rotina? ]

Calce.lsp – Calcular

2010-05-21T17:29:00.001+01:00

CALCE.lsp é uma simples rotina que permite efectuar simples cálculos de multiplacação, subtracção, soma e divisão. Uma vez chamada a função CALCE, é solicitado o primeiro número, o símbolo da operação e o segundo número, divulgando o resultado numa caixa de mensagem. Simples mas que pode fazer jeito.

[ Download ]

[ Como carregar a rotina? ]

Freehand.lsp – Desenho à mão-livre

2010-05-13T10:32:00.001+01:00

É verdade que com a introdução dos computadores no desenho técnico, utilizando-se progrmas sofisticados como o AutoCad, no fundo um estirador virtual, as características do desenho tornaram-se rigorosas, rígidas e, para além de todas as vantagens disso, a verdade é que perdeu-se o encanto do desenho à mão-livre e das suas naturais imprecisões. É verdade que para suprir essa falha também existem programas de esquiço (como o Autodesk SketchBook), onde se pretende reencontrar no processo criativo essa liberdade pictórica e expressionista, mas, diga-se o que se disser, não é a mesma coisa, daí que muitos arquitectos e designers não dispensem o papel, o lápis, a caneta e a borracha de apagar.

Seja como for, um pouco dentro deste contexto, alguém, muito bem, desenvolveu uma rotina auto-lisp que empresta aos desenhos um certo ar de mão-livre, daí a rotina chamar-se de “freehand”.

A sua utilização é muito simples e depois de chamado o comando, basta determinar alguns pouco parâmetros, facilmente compreensíveis, e de seguida seleccionar o desenho que se pretende caracterizar com o tal estilo de mão-livre. O resultado torna as linhas um pouco tremidas, que lhe emprestam dinâmica e com as extremidades a transporem as perpendiculares.

Resulta muito bem, especialmente em desenhos de alçados e vistas. Pensamos que tem alguma utilidade em trabalhos de ante-projecto e apresentação.

Experimentem.

[Download]

BUB.lsp - Rotina AutoLISP - repost

2010-05-07T09:30:00.000+01:00

Esta rotina BUB.lsp é em tudo idêntica à anteriormente publicada, a NCIR.lsp, sendo que também desenha uma seta (leader). A leader pode ter diversos segmentos e em variadas direcções. Deve ser dado um primeiro ponto, que corresponde à posição da ponta da seta e o último, seguido de Enter, corresponde à posição do centro do círculo onde será inscrito o número.

Como a NCIR, este rotina é particularmente útil para anotar materiais, em alçados, por exemplo, e equipamentos, etç. Para quem não gostar dos círculos, pode sempre apagar os mesmos, deixando apenas a leader e o número. Nada mais fácil e o resultado poderá ser mais elegante, principalmente quando há muitos elementos a identificar.

Autor da versão usada: Steve Waskow

Comando: BUB

(download)

ALLZ.lsp – Tansformar todas as coordenadas Z em elevação zero

2010-04-27T17:52:00.001+01:00

Não raras vezes, principalmente quando trabalhamos com programas de topografia, nomeadamente textos e curvas de nível, há necessidade de transformar as cotas com valor Z positivo em valores zero. É certo que o AutoCad já dispõe do comando Flatten Objects, no Menu Express/Modify, mas também é verdade que o processo é demorado e nem sempre com resultados satisfatórios.

A rotina de que falamos hoje, mostrou-se de todas as que conheço, como a mais rápida e eficiente. Poderá ter algumas limitações, já que não resolve entidades que tenham múltiplos valores Z, como as 3D Polyline e 3Dfaces, mas no resto tem bom desempenho.

É conveniente que ao seleccionar as entidades a alterar, estas estejam isoladas ou separadas das entidades já com valores zero. Também é conveniente que a selecção seja efectuada na vista normal, ou seja de topo, vista em planta.

Para a compilação da rotina e seu carregamento, para quem não souber, deve seguir as seguintes instruções:Link

[Download]

Often, especially when working with programs of topography, including text and contour lines, there is need to transform the coordinates with positive Z value to zero values. It is true that already have the Autocad eating Flatten Objects, in Menu Express / Modify, but it is also true that the process is time consuming and not always with satisfactory results.
The routine of which we speak today, was all that I know, as quickly and efficiently. You may have some limitations, since it does not resolve entities that have multiple Z values, such as 3D Polyline and 3DFACE, but otherwise performs well.
It is desirable that the selected entities to change, they are isolated or separated entities already with zero values. It is also desirable that the selection is carried out in normal view, in top view.
To compile the routine and its load, for those who do not know, should follow the following instructions: Link

Sorry for the bad translation.

[Download]

Glossário de termos técnicos relacionados com a Arquitectura

2010-04-21T17:17:00.001+01:00

Glossário de termos técnicos relacionados com Arquitectura e

View more presentations or Upload your own.

ADRL.lsp – Sequenciar letras

2010-03-11T15:57:00.001Z

ADRL.lsp é uma simples mas eficaz rotina que possibilita introduzir uma sequência de letras. Ideal para referenciar elementos como materiais, compartimentos, maquinarias, etc.

Deve introduzir o número de vezes que pretende sequenciar, o código ASCII-decimal correspondente à letra (65 para o “A” maiúsculo ou 97 para o “a” minúsculo) inicial ou de partida, o incremento, que no caso deve ser positivo, bem como deve definir a altura do texto e da rotação. Nada mais simples.

ADRL.lsp is a simple but effective routine that allows to introduce a sequence of letters. Ideal for items such as reference materials, machinery, etc..
You must enter the number of times to sequence, the code ASCII-decimal corresponding to the letter (65 for the capital "A" or 97 to “a” lower-case) or early departure, the increment, which in the case must be positive, and must set the text height and rotation.

Sorry for the poor translation, but is working at Google.

;INÍCIO DO CÓDIGO
;    ADRL.LSP   by: http://rotinasautolisp.blogspot.com/
;
;
;    Esta rotina introduz sequencialmente
;    letras maiúsculas
;    do abcedário.Útil para identificar elementos
;    do desenho, por exemplo compartimentos
;    ou materiais.
;
;
(DEFUN C:ADRL ()
;
(ALERT "Esta rotina introduz sequencialmente letras maiúsculas do abcedário.Útil para identificar elementos do desenho, por exemplo compartimentos ou materiais"
)
(SETVAR "CMDECHO" 0)
(SETQ E (GETINT "\nIntroduza o número de repetições: "))
(SETQ N (GETINT "\nIntroduza o código correspondente à primeira letra - A = 65: "))
(SETQ I (GETINT "\nIntroduza o incremento: "))
(SETQ H (GETREAL "\nIntroduza a altura do texto: "))
(SETQ R (GETREAL "\nIntroduza a rotação do texto: "))
;
(repeat E
(SETQ INPT (GETPOINT "\nIntroduza o ponto de inserção: "))
(SETQ NN (CHR N))
(COMMAND "TEXT" INPT H R NN)
(SETQ N(+ N I))
)
;
)
;FIM DO CÓDIGO

ADRN.lsp – Sequenciar números

2010-03-11T15:43:00.001Z

ADRN.lsp é uma simples mas eficaz rotina que possibilita introduzir uma sequência de números. Ideal para referenciar elementos como materiais, compartimentos, maquinarias, etc.

Deve introduzir o número de vezes que pretende numerar, o número inicial ou de partida, o incremento, que pode ser positivo oun egativo, mas um valor inteiro, bem como deve definir a altura do texto e da rotação. Nada mais simples.

ADRN.lsp is a simple but effective routine that allows to introduce a sequence of numbers. Ideal for items such as reference materials, machinery, etc..
You must enter the number of times you want to number the original number or departure, the increment, which may be positive oun egate, but an integer value, and should set the text height and rotation.

Sorry for the poor translation, but is working at Google.

;INÍCIO DO CÓDIGO
;    ADRN.LSP   by: http://rotinasautolisp.blogspot.com/
;
;    Esta rotina permite introduzir uma sequência de números. Pode atribuir um incremento, positivo ou
;    negativo. Ideal para identificar ou numerar elementos, por exemplos, compartimentos, materiais,
;    maquinaria, etc.
;
;
(DEFUN C:ADRN ()
;
(SETVAR "CMDECHO" 0)
(SETQ E (GETINT "\nIntroduzir o # de repetições: "))
(SETQ N (GETINT "\nIntroduzir o número de partida: "))
(SETQ I (GETINT "\nIntroduzir valor do incremento (número inteiro): "))
(SETQ H (GETREAL "\nINtroduzir valor da altura do texto: "))
(SETQ R (GETREAL "\nIntroduzir valor da rotação do texto: "))
;
(repeat E
(SETQ INPT (GETPOINT "\nPonto de inserção: "))
(COMMAND "TEXT" INPT H R N)
(SETQ N(+ N I))
)
;
)
;FIM DO CÓDIGO

Totlen.lsp – Medir comprimentos

2009-10-21T10:24:00.001+01:00

Totlen é uma rotina autolisp que facilita a quantificação dos comprimentos de várias entidades como linhas curvas e polylines. Apenas não mede círculos fechados. A mais valia da rotina está no valor total que pode ser obtido seleccionando-se as diferentes entidadades em simultâneo. Por exemplo: Para medir guias de passeio. Basta uma boa utilização das layers e da rotina e tudo fica simples.

Totlen is an AutoLISP routine that facilitates the quantification of the lengths of various entities such as lines and polylines. Just do not measure closed circles. The added value of the routine is the total amount that can be obtained by selecting the different entidadades simultaneously. For example: To measure walking guides. Just a good use of layers and the routine and everything is simple.

Sorry for the poor translation, but is working at Google.

Download: Link

[Código/Code]

TXTANG – Rotina AutoLisp

2009-09-08T17:46:00.001+01:00

TXTANG é uma simples rotina AutoLisp que permite de modo fácil alinhar uma entidade texto com o alinhamento de outra entidade. Tem utilidade sobretudo quando se pretendem ângulos desconhecidos.

Depois do comando, é pedido para seleccionar a entidade texto a alinhar e de seguida dois pontos da entidade referência, por exemplo uma linha. Nada mais fácil.

TXTANG is a simple routine that allows AutoLisp so easy to align one entity with the text alignment of another entity. Is useful especially when you want unknown angles.
After the command is prompted to select the body text to align and then two points of the reference entity, such a line. Nothing easier.

Nome do ficheiro: TXTANG.lsp

Comando: TXTANG

;Início do Código
;********* rotina desenvolvida por http://rotinasautolisp.blogspot.com/ - 05/03/2004
;
;
(defun c:txtang (/ a ht n i b1 b c d b2)
(prompt "\nA ROTINA QUE ALINHA TEXTOS POR DOIS PONTOS")
(setvar "cmdecho" 0)
(setq a (ssget))
(setq ht (getangle "\nDEFINIÇÃO DO ÂNGULO: "))
(setq n (sslength a))
(setq i 0)
(repeat n
        (setq b1 (entget (ssname a i)))
        (setq i (1+ i))
        (setq c (assoc 50 b1))
        (setq d (cons (car c) ht))
        (setq b2 (subst d c b1))
        (entmod b2)
)
(princ "copyright: http://rotinasautolisp.blogspot.com/")
(PRINC)
)
;Fim do Código

Draftsperson.net

2008-12-16T18:24:00.001Z

Draftsperson.net é um sítio interessante, repleto de assuntos de interesse, nomeadamente tutoriais sobre programação em AutoLisp, rotinas AutoLisp, truques e dicas, blocos e muito mais. Vale a pena passar por lá.

- URL

RESPACE - Rotina Autolisp

2008-12-16T18:12:00.001Z

RESPACE é uma interessante e útil rotina que permite seleccionar um conjunto de linhas de texto e espaçar as mesmas de forma equidistante, usando-se um valor que pode ser inserido pelo teclado ou picando dois pontos com o mouse. O espaçamento e alinhamento à esquerda é realizado mesmo para textos dispersos.

Os textos podem ser seleccionados simultaneamente por janela mas deve ter em atenção a ordem que pretende para cada linha pelo que nesta situação será conveniente seleccionar linha a linha.

Nome do ficheiro: RESPACE.lsp

Comando: RSP

(princ "\nRe-space (RS) Version 2.0 4-13-91 by Jon Shapiro")
;
;This program will take a series of text strings, selected individually
;and in sequence, and revise the spacing between each line. This
;should be especially useful after running a lisp routine to revise the
;height of a group of text entities. Each entity would need to have it's
;insert point shifted in accordance with the new text height.
;
;Version 2.0 has been improved to handle other types of text justification
;modes in addition to left justified (i.e. right, middle).

;----------------------------------
;Error handler
(defun MYERR (MSG)
   (if (and (/= MSG "Function cancelled") (/= MSG "console break"))
      (progn
         (princ "\nError: ")
         (princ MSG)
      )
   )
   (setq *error* OLDER)
   (setvar "cmdecho" 1)
   (princ)
)
;---------------------------
;
(defun c:rsp (/ older tmpdis ss sslen ctr ent txtrot just code inspt
               xpt ypt entlis tdisp x y pt theta)
   (setvar "cmdecho" 0)
   (command ".undo" "m")
   (setq older *error*
         *error* myerr
   )
   (initget (+ 1 2 4)) ;disallow negative and zero responses
   (if (= dis nil)
      (progn
         (initget (+ 1 2 4)) ;disallow nul negative and zero responses
         (setq dis (getdist "\nDistance between text strings: "))
      )
      (progn
         (initget (+ 2 4)) ;disallow negative and zero responses
         (setq tmpdis dis
               dis (getdist (strcat "\nDistance between text strings <"
                         (rtos dis) ">: " )
                   )
         );close setq
         (if (= dis nil)
            (setq dis tmpdis)
         )
      );close progn
   );close if
   (princ "\nSelect text strings to respace in sequence: ")
   (setq ss (ssget)
         sslen (sslength ss)
         ctr 0 ;initialize counter
   );close setq
   (while (and (/= ss nil) (>= sslen 0) (< ctr sslen))
      (setq ent (ssname ss ctr))
      (if (= ctr 0)
         (progn
            (setq txtrot (cdr (assoc 50 (entget ent)))
                  just (cdr (assoc 72 (entget ent)))
            )
            (if (> just 0)
               (setq code 11)    ;non-left justified
               (setq code 10)    ;left justified
            )
            (setq inspt (cdr (assoc code (entget ent)))
                  xpt (car inspt)
                  ypt (cadr inspt)
            );close setq
         );close progn
         (progn
;------------------------------------------------------------------------
;lets take different action depending on rotation angle of text entities
;------------------------------------------------------------------------

;---------------------------------------------------
;Lets also check text justification mode.
;We should use group code 10 for left justified
;text. All others we should use group code 11
;this will maintain justification
;---------------------------------------------------

            (cond
               (   (< txtrot (* 0.5 pi))       ;if rotation angle <90 deg
                   (setq entlis (entget ent)
                         just (cdr (assoc 72 entlis))
                   )
                   (if (> just 0)
                      (setq code 11)
                      (setq code 10)
                   )
                   (setq tdisp (* ctr dis)
                         x (+ xpt (* tdisp (sin txtrot)))
                         y (- ypt (* tdisp (cos txtrot)))
                         pt (list x y)
                         entlis (subst (cons code pt) (assoc code entlis) entlis)
                   );close setq
                   (entmod entlis)
               );close 1st cond

               (   (and (< txtrot pi) (>= txtrot (* 0.5 pi))) ;if rotation angle <180 & >= 90 deg
                   (setq entlis (entget ent)
                         theta (- txtrot (* 0.5 pi))
                         tdisp (* ctr dis)
                         x (+ xpt (* tdisp (cos theta)))
                         y (+ ypt (* tdisp (sin theta)))
                         pt (list x y)
                         entlis (subst (cons code pt) (assoc code entlis) entlis)
                   );close setq
                   (entmod entlis)
               );close 2nd cond

               (   (and (< txtrot (* 1.5 pi)) (>= txtrot pi)) ;if rot angle <270 & >= 180 deg
                   (setq entlis (entget ent)
                         theta (- txtrot pi)
                         tdisp (* ctr dis)
                         x (- xpt (* tdisp (sin theta)))
                         y (+ ypt (* tdisp (cos theta)))
                         pt (list x y)
                         entlis (subst (cons code pt) (assoc code entlis) entlis)
                   );close setq
                   (entmod entlis)
               );close 3rd cond

               (   (and (< txtrot (* 2.0 pi)) (>= txtrot (* 1.5 pi))) ;if rot angle <360 & >= 270 deg
                   (setq entlis (entget ent)
                         theta (- txtrot (* 1.5 pi))
                         tdisp (* ctr dis)
                         x (- xpt (* tdisp (cos theta)))
                         y (- ypt (* tdisp (sin theta)))
                         pt (list x y)
                         entlis (subst (cons code pt) (assoc code entlis) entlis)
                   );close setq
                   (entmod entlis)
               );close 4th cond
            );close cond text rotation angles
;-------------------------------------------------------------------------
         );close progn
      );close if
      (setq ctr (1+ ctr)) ;increment counter
   );close while
   (setvar "cmdecho" 1)
   (setq *error* older)
   (princ);quiet exit
);close defun respace
(princ);quiet load

TXOUT.lsp - Rotina AutoLisp

2008-12-16T17:49:00.001Z

TXOUT é uma rotina AutoLisp que permite de forma fácil exportar texto de um ficheiro de AutoCad (DWG) para um documento do Notepad. O ficheiro .txt é guardado automaticamente no directório onde se encontra o ficheiro DWG.

No caso do ficheiro DWG ser novo e ainda não estar gravado, em princípio o ficheiro .txt seguirá para a pasta Os Meus Documentos.

Depois de accionado o comando, deve-se seleccionar o texto que se pretende exportar, sendo de seguida solicitado o nome que pretende dar ao ficheiro.

O texto a exportar pode ser seleccionado por janela ou picando linha a linha. Esta segunda opção é a ideal para colocar as linhas de texto segundo uma ordem desejada.

Esta rotina é extremamente útil quando se pretende aproveitar textos inseridos para elaboração de outros documentos escritos, nomeadamente no Word.

Comando: TXOUT

;===========================================
;
;    Rotina copiada do Autodesk Discussion Group
;    Outubro 2006
;
;    Esta rotina permite copiar de forma fácil, textos inseridos no
;       ficheiro DWG para um ficheiro de texto no NotePad
;    O ficheiro .txt é gravado no directório de origem do ficheiro DWG
;
;
;==========================================
(defun c:TXOUT (/ elist en fn fname i ss txt)
(setvar "cmdecho" 0)
(prompt "\n* Text file written to directory of current drawing *")
(if (setq ss (ssget (list (cons 0 "TEXT"))))
(progn (setq fname (getstring "\n* Enter text file name: "))
(if (= fname "")
(setq fname (substr (getvar "dwgname") 1 (- (strlen (getvar
"dwgname")) 4))))
(setq fn (open (strcat (getvar "dwgprefix") fname ".txt") "w"))
(setq i -1)
(repeat (sslength ss)
(setq i (1+ i))
(setq en (ssname ss i)
elist (entget en)
txt (cdr (assoc 1 elist)))
(write-line txt fn))
(close fn)))
(princ (strcat "\n* Text file " (getvar "dwgprefix") fname " has been
created *"))
(setvar "cmdecho" 1)

(setq fn (strcat (getvar "dwgprefix") fname ".txt"))
(startapp (strcat "Notepad " (chr 34) fn (chr 34)))
(princ))

;===========================================

NCIR.lsp - Rotina AutoLISP

2008-09-16T16:31:00.001+01:00

Esta simples rotina permite introduzir sequências de números dentro de círculos (bolhas).

É deveras útil para numerar elementos como materiais, equipamentos, etç.

Para cada número deve ser chamada a rotina. Se não se alterar o respectivo número, os mesmos são inseridos de forma sequencial.

Para alterar o tamanho do círculo/texto, deve-se previamente alterar o valor da variável DIMSCALE.

A rotina cria uma layer própria, chamada "Bolhas_Anotacoes", bem como faz dela a layer corrente. Editando ou apagando as respectivas linhas de código é possível alterar ou apagar esta situação.

Autor: www.rotinasautolisp.blogspot.com

Comando: NCIR

DOWNLOAD

TXTS.lsp - Rotina AutoLisp

2008-09-04T10:25:00.001+01:00

Esta simples rotina permite somar valores numéricos.
Para o efeito deve seleccionar os números que pretende somar, podendo fazê-lo de forma múltipla, por janela, ou picando individualmente cada entidade. Finalmente, deve picar num número que deverá estar reservado para o total, o qual será actualizado em função da soma.
Esta rotina é particularmente útil para soma de valores em tabelas.

Nota: No caso de somar valores com casas decimais, o separador deve ser ponto e não vírgula. Pode controlar o número de casas decimais alterando o valor da variável de sistema LUPREC.

Comando: TXTS

(download)

Lisp 2 HTML - Formatar código Lisp em HTML

2008-04-23T16:46:00.001+01:00

Neste sítio, pode-se utilizar uma ferramenta de conversão de código Lisp para HTML. O código gerado pode ser copiado e inserido num blog ou página web, exibindo-se assim a codificação por cores, tal como acontece no editor Visual Lisp.

O código abaixo, de uma rotina por nós já aqui publicada, é disso exemplo.

(fonte: Blog do Neyton)

;Comando: BINT

(defun c:BINT ( / ss point snap echo olderr)
(setq snap (getvar "osmode"))
(setq echo (getvar "cmdecho"))
(setq olderr *error*)
(setq *error* break_error)
(setvar "cmdecho" 0)
(while (not ss)
    (setq ss (entsel "\nSeleccione a linha a quebrar: "))
);while
(setvar "osmode" 32)
(while (not point)
    (setq point
    (osnap (getpoint "\nSeleccione a linha a quebrar: ") "int"))
);while
(setvar "osmode" snap)
(command "break" ss "f" point "@")
(setvar "cmdecho" echo)
(setq *error* olderr)
(princ)
)

(defun break_error (msg)
(princ (strcat "\nError: " msg))
(setvar "osmode" 0)
(setvar "cmdecho" 1)
(princ)
)

;Fim do código

CPOL.lsp - Rotina AutoLISP

2008-04-21T15:35:00.001+01:00

Descrição: Esta rotina permite copiar entidades utilizando uma selecção com um polígono irregular. A rotina inicia com o pedido de uma de duas opções:
Opção WP: selecciona as entidades dentro do polígono;
Opção CP: selecciona as entidades dentro e cruzadas pelo polígono

Autor: www.rotinasautolisp.blogspot.com

Comando: CPOL

(download)

NL.lsp - Rotina AutoLISP

2008-04-17T18:32:00.001+01:00

Descrição: Esta simples rotina permite criar novas layers a partir das linhas de comando, evitando abrir a caixa de diálogo do Layer Manager. A rotina solicita o nome da layer a criar e o número da cor. Caso se opte por não escolher a cor, por defeito será atribuída a cor 7 / white.

Autor: www.rotinasautolisp.blogspot.com

Comando: NL

;;INÍCIO DO CÓDIGO
;-------------------------------------------------------------------------------------
;2008 - www.rotinasautolisp.blogspot.com
;;rotina que permite criar novas layers a partir da linha de comandos
;;comando: nl
;-------------------------------------------------------------------------------------
(defun C:nl()
(princ "Esta simples rotina permite criar layers a partir das linhas de comando.")
(setq namelayer (getstring "\n Indique o nome da nova layer : "))
(setq layercolor (getint "\n Indique o numero da cor a atribuir à layer - Se não escolher fica definada na cor 7/white: "))
(if (= layercolor nil)(setq layercolor 7))
(command "layer" "new" namelayer "color" layercolor namelayer "")
(princ)
)
;;FIM DO CÓDIGO

BINT.lsp - Rotina AutoLISP

2008-04-15T15:56:00.001+01:00

Nome do ficheiro: BINT.lsp

Descrição: Esta rotina permite fazer um break numa intersecção seleccionada. Deve-se seleccionar primeiramente a linha que se pretende quebrar e seguidamente seleccionar a intersecção.
Rotina muito útil uma vez que é mais rápida e objectiva que o comando Break

Nome do comando: BINT

Como carregar (load)?

Código fonte:

;Início do código

;Esta rotina permite fazer um break numa intersecção seleccionada
;Deve-se seleccionar primeiramente a linha que se pretende quebrar
;e seguidamente seleccionar a intersecção.
;Rotina muito útil uma vez que é mais rápida e objectiva que o comando Break
;Comando: BINT

(defun c:BINT ( / ss point snap echo olderr)
(setq snap (getvar "osmode"))
(setq echo (getvar "cmdecho"))
(setq olderr *error*)
(setq *error* break_error)
(setvar "cmdecho" 0)
(while (not ss)
    (setq ss (entsel "\nSeleccione a linha a quebrar: "))
);while
(setvar "osmode" 32)
(while (not point)
    (setq point
    (osnap (getpoint "\nSeleccione a linha a quebrar: ") "int"))
);while
(setvar "osmode" snap)
(command "break" ss "f" point "@")
(setvar "cmdecho" echo)
(setq *error* olderr)
(princ)
)

(defun break_error (msg)
(princ (strcat "\nError: " msg))
(setvar "osmode" 0)
(setvar "cmdecho" 1)
(princ)
)

;Fim do código

AutoLisp - Tutorial - 1

2008-04-15T15:36:00.001+01:00

Tutorial sobre AutoLISP, em inglês.---------------------------------

INCRE.lsp - Rotina LISP

2008-04-15T15:07:00.001+01:00

Nome do ficheiro: INCRE.lsp

Descrição: Esta rotina permite incrementar um determinado valor a entidades de texto numérico. Aceita valores negativos e positivos e permite sellecionar simultaneamente várias entidades. Permite incrementar valores inteiros ou com casas decimais

(comando: INCRE)

código fonte:

;Início do código
(defun chgterr (s)
   (if (/= s "Function cancelled")
      (princ (strcat "\nError: " s))
   )
   (setq p nil)
   (setq *error* olderr)
   (princ)
)

;Rotina que permite incrementar um determinado valor a entidades de texto numérico.
;Aceita valores negativos e positivos e permite sellecionar simultaneamente várias entidades
;Permite incrementar valores inteiros ou com casas decimais

(defun C:INCRE (/ p l n e os as ns st s nsl osl sl si chf chm olderr)
   (setq olderr *error*
         *error* chgterr
         chm     0)
   (setq p (ssget))
   (setq inc (getreal "\nValor do incremento:"))
      (setq l 0 n (sslength p))
      (while (< l n)
         (if (= "TEXT"
                (cdr (assoc 0 (setq e (entget (ssname p l))))))
               (progn
                (setq s (cdr (setq as (assoc 1 e))))
                (setq mn (atof s))
                (setq nm (+ mn inc))
                (setq s (rtos nm))
                (setq e (subst (cons 1 s) as e))
                (entmod e)
                (setq chm (1+ chm))
               )
         )
         (setq l (1+ l))
      )
   (princ chm)
   (princ " entidades de texto numérico")
   (princ " alteradas.")
   (terpri)
   (setq *error* olderr)
   (princ)
)
;Fim do código

Como carregar as rotinas AutoLISP?

2008-04-15T14:56:00.001+01:00

Para criar um ficheiro com a extensão lsp, deve copiar o código da rotina e colar o mesmo num qualquer editor de texto simples, tal como o Notepad ou o Notepad++.

Depois, com a opção de All Files aberta, deve atribuir um nome ao ficheiro bem como a extensão lsp (exemplo: ficheiro.lsp).

Seguidamente, o ficheiro criado, ou no caso de ter sido descarregado de um sítio da net, deverá ser colocado numa determinada pasta no computador onde corre o AutoCad. Não é obrigatório que fique dentro do directório do programa que vier a utilizar a rotina mas por uma questão de organização não seria de descurar a criação ali de uma pasta reservada para as rotinas Lisp.

Como carregar a rotina: Partindo do princípio que usa o AutoCad, deverá seguir os seguintes passos:
Menú Tools/AutoLisp/Load Aplication - Deverá procurar o caminho onde guardou a rotina, seleccionar a pretendida e efectuar o comando Load. Esta opção carrega a rotina apenas para a sessão em curso.

Para que a rotina fique disponível para futuras sessões deverá ser utilizado o aplicativo Startup Suite, disponível na anterior caixa de diálogo, e efectuar Add (seleccionando e adicionando a rotina pretendida. Deste modo, ao inciar uma nova sessão do AutoCad a rotina será carregada automáticamente. Como alternativa seria necessário editar um ficheiro próprio existente na raíz do AutoCad, mas considerando a simplicidade do Startup Suite, não nos debruçaremos sobre o assunto.

Uma vez carregada a rotina deve ser chamado o respectivo comando. Quando não está devidamente indicado ou divulgado o nome do comando (repare-se que o nome do ficheiro poderá ser diferente do comando) deverá abrir a rotina com um editor de texto simples e verificar qual o comando que está atribuído. Habitualmente o mesmo surge a seguir à função "defun C:".

Esperemos ter ajudado, não quem já sabe mas para utilizadores iniciantes.

O que é o AutoLISP?

2008-04-15T14:42:00.001+01:00

O que é AutoLISP?
        O AutoLISP é uma versão reduzida da linguagem de programação CommomLISP, adaptada pela AutoDESK e fornecida juntamente com o AutoCAD, com o objetivo de dar ao usuário condições de criar seus próprios aplicativos dentro do AutoCAD, ou seja, programar soluções que ainda não existem prontas no software. Assim, sendo uma linguagem de programação, o AutoLISP possui uma sintaxe própria, tipos de dados, estrutura de dados, métodos de alocação de memória, estruturas de decisão, etc.
        A linguagem LISP é bastante conhecida entre os programadores e utilizada na implementação de softwares de inteligência artificial. O nome LISP vem da expressão em inglês List Processing. A linguagem foi concebida com base no conceito de Processamento de Listas, e é a segunda mais antiga linguagem de programação de alto nível ainda usada por computadores modernos (a mais antiga é FORTRAN).
        O primeiro interpretador LISP foi desenvolvido no final da década de 50 por John McCarthy e um grupo de pesquisadores em computação no MIT (Massachusetts Institute of Technology).
        O dialeto AutoLISP derivou-se do XLISP, abreviatura para eXperimental LISP, desenvolvido por Davis Betts por volta de 1980.
        Para implementar o "AutoLISP" ao AutoCAD, foram utilizados aplicativos desenvolvidos em programação C, chamados ADS (AutoCAD Development System). O AutoLISP surgiu pela primeira vez no AutoCAD versão 2.15 mas não foi documentado até versão 2.17. Até então o nome "AutoLISP" não era usado. Em seu lugar, a Autodesk referia-se às funções LISP como "o novo recurso de Variáveis e Expressões". A linguagem era tão experimental que não havia nem mesmo previsão para looping de programa para a versão 2.18.
        A pretensão inicial da Autodesk era que o AutoLISP fosse uma ferramenta de programação para programadores experientes. O brilhantismo acessível do AutoLISP surpreendeu a todos. Alguns usuários sem nenhuma experiência em programação descobriram ser possível escrever facilmente algumas linhas de código que automatizavam as operações tediosas e repetitivas do AutoCAD.
        Normalmente, uma grande parte das pessoas utilizam o AutoCAD apenas para fins de desenho, tendo pouco convívio com manuais e literaturas especializadas. Na realidade, o AutoCAD possui um universo de recursos, muitos deles, pouco explorados, como é o caso do AutoLISP.
        As funções matemáticas e trigonométricas no AutoLISP foram significamente melhoradas, já que a maior parte das aplicações em AutoLISP requer cálculos. Apesar de o AutoLISP não ser como o FORTRAN, a implementação da Autodesk contém muitas extensões à linguagem LISP projetadas para fazer fluir a execução de programas matematicamente intensivos.
        Um exemplo de uma destas extensões é encontrado na expressão polar, que calcula as coordenadas de uma nova lista de pontos dado um ponto atual, a distância e o ângulo para o ponto desejado. Esta função não é encontrada na maioria das implementações do LISP, mas é extremamente conveniente durante o desenvolvimento de aplicações em AutoLISP.
        A evolução do AutoLISP dentro do ambiente AutoCAD foi largamente direcionada por pedidos de desenvolvedores de aplicativos e usuários finais do produto AutoCAD. Como resultado, o AutoLISP tornou-se uma ferramenta valiosa para a customização do AutoCAD.
        O termo customização faz parte do jargão da computação gráfica. Customizar significa direcionar um aplicativo, como o AutoCAD, a desempenhar tarefas bem específicas, para as quais ele não foi originalmente projetado, facilitando o trabalho do usuário final.
        Há outras linguagens nativas no AutoCAD, como o ADS (AutoCAD Development System, biblioteca de funções compiláveis por alguns compiladores C), o DCL (Dialog Control Language) e as funções DIESEL (Direct Interpretively Evaluated String Expression Language) . O ADS é adequado para implementação de programas mais sofisticados, com acesso pesado a banco de dados e intenso processamento matemático. É mais complexo que o AutoLISP, requer um compilador C e muitas horas de programação, sendo mais eficiente, apesar do alto custo final.
        O AutoLISP se torna vantajoso para pequenos programas, porque é mais simples de programar e não requer compilador externo. É uma linguagem de fácil assimilação e de grande utilidade para a melhoria da performance dos usuários do AutoCAD.
        Uma característica importante no AutoLISP, que o torna muito interessante, é a possibilidade de utilizar comandos que interagem diretamente com o AutoCAD. Ou seja, através do AutoLISP pode-se construir programas que solicitam ao usuário determinadas informações, processam essas informações e interferem sobre a área de trabalho do AutoCAD. Para algumas áreas, como a engenharia, por exemplo, esse recurso representa um potencial tremendo. Pode-se obter informações estratégicas a partir do desenho que permitirão calcular e definir outros elementos que podem ser desenhados automaticamente. Assim, o usuário pode começar um desenho e assistir a conclusão dele numa velocidade bem maior do que se conseguiria fazendo a mesma coisa manualmente. Com o conhecimento do AutoLISP, tornam se inúmeras as possibilidades de melhoria de performance num escritório.

(fonte: www.dz9cad.com.br)