Você está aqui: AutoCAD Civil 3D .NET C# ::: Dicas & Truques ::: Superfície - Surface

Como retornar a quantidade de superfícies em um documento do AutoCAD Civil 3D usando C# e a função GetSurfaceIds()

Quantidade de visualizações: 300 vezes
Em várias situações nós precisamos obter e retornar a quantidade de superfícies em um documento do AutoCAD Civil 3D. Para isso nós podemos usar a função GetSurfaceIds() do objeto CivilDocument. Esta função nós retorna uma ObjectIdCollection contendo todos os ids das surfaces contidas no documento.

Assim, tudo que temos a fazer é acessar a propriedade Count da ObjectIdCollection, que nos retorna um número inteiro representando a quantidade de superfícies no documento atual do AutoCAD Civil 3D.

Veja o código AutoCAD Civil 3D C# completo para o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

using System;
using Autodesk.AutoCAD.Runtime;
using Autodesk.Civil.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;

namespace Estudos {
  public class Class1 : IExtensionApplication {
    [CommandMethod("Superficie")]
    public void Superficie() {
      // vamos obter uma referência ao documento atual do Civil 3D
      CivilDocument doc = CivilApplication.ActiveDocument;

      // agora vamos obter os ids de todas as superfícies
      ObjectIdCollection superficies = doc.GetSurfaceIds();

      // vamos obter a quantidade de superfícies no documento
      int quant_superficies = superficies.Count;

      // e mostramos o resultado
      Editor editor = Application.DocumentManager.MdiActiveDocument.Editor;
      editor.WriteMessage("\nO documento possui " + quant_superficies +
        " superfícies.");
    }

    public void Initialize() {
      // pode deixar em branco
    }

    public void Terminate() {
      // pode deixar em branco
    }
  }
}

Ao executar este código AutoCAD Civil 3D C# nós teremos o seguinte resultado:

O documento possui 2 superfícies.

Link para compartilhar na Internet ou com seus amigos:

Python ::: Fundamentos da Linguagem ::: Estruturas de Controle

Python para iniciantes - Como usar a instrução break em Python

Quantidade de visualizações: 10294 vezes
A instrução break da linguagem Python é usada para interromper a execução de um laço for ou while. Observe que se o laço possuir um bloco else, este não será executado se a instrução break for usada.

Veja um exemplo de um laço for que é interrompido se o valor da variável de controle for 5:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# função principal do programa
def main():
  for i in range(0, 21):
    print(i)
    if i == 5:
      break
  
if __name__== "__main__":
  main()

Ao executarmos este código nós teremos o seguinte resultado:

0
1
2
3
4
5


Java ::: Pacote java.awt.event ::: KeyEvent

Java Swing - Como obter o código da tecla pressionada usando o método getKeyCode() da classe KeyEvent do Java

Quantidade de visualizações: 4029 vezes
O método getKeyCode() da classe KeyEvent é usado quando queremos obter o código da tecla pressionada durante um evento KEY_PRESSED ou KEY_RELEASED. Para o evento KEY_TYPED, o keyCode é VK_UNDEFINED.

Veja um trecho de código no qual usamos o método getKeyCode() para obter e informar o código da tecla pressionada durante um evento keyPressed:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

package estudos;

import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class Janela extends JFrame implements KeyListener{
  public Janela(){
    super("Eventos do Teclado");
    Container c = getContentPane();
    FlowLayout layout = new FlowLayout(FlowLayout.LEFT);
    c.setLayout(layout);
    
    // vamos adicionar o objeto listener 
    addKeyListener(this);

    setSize(350, 250);
    setVisible(true);
  }
    
  @Override
  public void keyPressed(KeyEvent e){
    // vamos obter o código da tecla pressionada
    int codigo = e.getKeyCode();
    JOptionPane.showMessageDialog(null, "O código da tecla pressionada é: " + codigo);  
  }
    
  @Override
  public void keyReleased(KeyEvent e){
    // sem implementação
  }

  @Override
  public void keyTyped(KeyEvent e){
    // sem implementação
  }   
  
  public static void main(String args[]){
    Janela j = new Janela();
    j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  }
}

Ao executar este código e pressionarmos uma tecla nós teremos o seguinte resultado:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

O código da tecla pressionada é: 65

É importante observar que o código da tecla pode ser obtido somente nos eventos keyPressed e keyReleased. Para o evento keyTyped o retorno do método getKeyCode() é VK_UNDEFINED.


C++ ::: Dicas & Truques ::: Arquivos e Diretórios

Como excluir um diretório em C++ usando a função rmdir()

Quantidade de visualizações: 8246 vezes
Em algumas situações nossos códigos C++ precisam excluir diretórios. Isso pode ser feito com o auxílio da função _rmdir() ou rmdir(), disponível no header direct.h (trazido da linguagem C). Veja a assinatura desta função:

int _rmdir(const char *pathname);
Se o diretório for excluído com sucesso a função retornará o valor 0. O retorno será -1 se um erro ocorrer. Neste caso a variável global errno será definido como um dos seguintes valores:

a) ENOTEMPTY - Directory not empty - O diretório não está vazio e portanto não pode ser excluído;

b) ENOENT - No such file or directory - O caminho do diretório é inválido;

c) EACCESS - Acesso negado - Algum outro programa está usando este diretório e mantém controle sobre o mesmo.

Veja um trecho de código C++ no qual excluímos um diretório:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <iostream>
#include <direct.h>

using namespace std;

int main(int argc, char *argv[]){
  // vamos excluir este diretório
  char diretorio[] = "C:\\Dev-Cpp\\estudos";

  // vamos testar se houve erro na exclusão do diretório
  if(rmdir(diretorio) == -1){
    cout << "Erro: " << strerror(errno) << endl;
  }
  else{
    cout << "Diretório excluído com sucesso" << endl;
  }

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

É possível usar a versão Unicode de _rmdir(), ou rmdir(). O método _wrmdir(), também presente em direct.h é útil quando precisamos internacionalizar nossas aplicações. Veja o exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <iostream>
#include <direct.h>

using namespace std;

int main(int argc, char *argv[]){
  // vamos excluir este diretório
  wchar_t diretorio[] = L"C:\\Dev-Cpp\\estudos";

  // vamos testar se houve erro na exclusão do diretório
  if(_wrmdir(diretorio) == -1){
    cout << "Erro: " << strerror(errno) << endl;
  }
  else{
    cout << "Diretório excluído com sucesso" << endl;
  }

  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}



Python ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas

Como calcular a apótema de um polígono regular de N lados em Python

Quantidade de visualizações: 469 vezes
Uma das formas mais comuns de se obter a área de um polígono regular é usando a seguinte fórmula:

\[\text{A} = \frac{1}{2} \cdot \text{p} \cdot \text{a} \]

Onde:

p = Perímetro, ou seja, a soma dos comprimentos de todos os lados.
a = Apótema, isto é, uma parte que une o centro do polígono ao meio de qualquer lado que esteja perpendicular.

Agora que já estamos alinhados, saiba que calcular a apótema de um polígono regular "na mão" é fácil, já que só precisamos medir a distância de dois lados opostos e dividir por dois ou traçar linhas cruzadas e medir a distância de um dos lados até a interseção dessas linhas. No entanto, em programação a coisa já é um pouco mais complicada.

Nesta dica mostrarei como podemos realizar esta tarefa em Python. Para isso usaremos alguns truques de trigonometria. Comece analisando a seguinte imagem:



Note que temos um pentágono com cada lado medindo 4 metros. Recorde que um pentágono é um polígono regular de 5 lados. Para deixar a dica mais didática eu coloquei também uma linha azul representando a apótema do polígono e as linhas cruzadas.

Veja agora o código Python que recebe a quantidade de lados do polígono, o comprimento dos lados e retorna a apótema:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# vamos importar o módulo Math
import math

# função que calcula e retorna a apótema de um
# polítono regular
def calcular_apotema(lados, comprimento):
  # a quantidade de lados e o comprimento deles
  # não podem ser negativos
  if lados < 0 or comprimento < 0:
    return -1
 
  # calculamos a apótema
  return (comprimento / (2 * math.tan((180 / lados)
    * math.pi / 180)))
  
# função principal do programa
def main():
  # vamos ler a quantidade de lados
  lados = int(input("Informe a quantidade de lados: "))
  
  # vamos ler o comprimento dos lados
  comprimento = int(input("Informe o comprimento dos lados: "))

  # e agora calculamos a apótema dos polígono
  apotema = calcular_apotema(lados, comprimento)

  # e mostramos o resultado
  print("A apótema do polígono é: {0}".format(apotema))

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

Informe a quantidade de lados: 5
Informe o comprimento dos lados: 4
A apótema do polígono é: 2.7527638409423476


Python ::: Dicas & Truques ::: Programação Orientada a Objetos

Programação orientada a objetos em Python: Classes, objetos, métodos e variáveis de instância - Atualizado

Quantidade de visualizações: 13700 vezes
A melhor forma de entender a programação orientada a objetos (OOP) é começar com uma analogia simples. Suponha que você queira dirigir um carro e fazê-lo ir mais rápido pressionado o acelerador. O que deve acontecer antes que você seja capaz de fazer isso? Bem, antes que você possa dirigir um carro, alguém tem que projetá-lo. Um carro geralmente começa com desenhos feitos pelos engenheiros responsáveis por tal tarefa, tal qual a planta de uma casa. Tais desenhos incluem o projeto de um acelerador que possibilita ao carro ir mais rápido. O pedal do acelerador "oculta" os mecanismos complexos responsáveis por fazer o carro ir mais rápido, da mesma forma que o pedal de freio "oculta" os mecanismos que fazem o carro ir mais devagar e o volante "oculta" os mecanismos que fazem com que o carro possa virar para a direita ou esquerda. Isso permite que pessoas com pequeno ou nenhum conhecimento de motores possam facilmente dirigir um carro.

Infelizmente, não é possível dirigir o projeto de um carro. Antes que possamos dirigí-lo, o carro deve ser construído a partir do projeto que o descreve. Um carro já finalizado tem um pedal de aceleração de verdade, que faz com que o carro vá mais rápido. Ainda assim, é preciso que o motorista pressione o pedal. O carro não acelerará por conta própria.

Agora vamos usar nosso exemplo do carro para introduzir alguns conceitos de programação importantes à programação orientada a objetos. A execução de uma determinada tarefa em um programa exige um método. O método descreve os mecanismos que, na verdade, executam a tarefa. O método oculta tais mecanismos do usuário, da mesma forma que o pedal de aceleração de um carro oculta do motorista os mecanismos complexos que fazem com que um carro vá mais rápido. Em Python, começamos criando uma unidade de programa chamada classe para abrigar um método, da mesma forma que o projeto de um carro abriga o design do pedal de acelerador. Em uma classe fornecemos um ou mais métodos que são projetados para executar as tarefas da classe. Por exemplo, a classe que representa uma conta bancária poderia conter muitos métodos, incluindo um método para depositar dinheiro na conta, outro para retirar dinheiro, um terceiro para verificar o saldo, e assim por diante.

Da mesma forma que não podemos dirigir o projeto de um carro, nós não podemos "dirigir" uma classe. Da mesma forma que alguém teve que construir um carro a partir de seu projeto antes que pudessémos dirigí-lo, devemos construir um objeto de uma classe antes de conseguirmos executar as tarefas descritas nela.

Quando dirigimos um carro, o pressionamento do acelerador envia uma mensagem ao carro informando-o da tarefa a ser executada (neste caso informando-o de que queremos ir mais rápido). Da mesma forma, enviamos mensagens aos objetos de uma classe. Cada mensagem é uma chamada de método e informa ao objeto qual ou quais tarefas devem ser executadas.

Até aqui nós usamos a analogia do carro para introduzir classes, objetos e métodos. Já é hora de saber que um carro possui atributos (propriedades) tais como cor, o número de portas, a quantidade de gasolina em seu tanque, a velocidade atual, etc. Tais atributos são representados como parte do projeto do carro. Quando o estamos dirigindo, estes atributos estão sempre associados ao carro que estamos usando, e cada carro construído a partir do projeto sofrerá variações nos valores destes atributos em um determinado momento. Da mesma forma, um objeto tem atributos associados a ele quando o usamos em um programa. Estes atributos são definidos na classe a partir da qual o objeto é instanciado (criado) e são chamados de variáveis de instância da classe.

Veremos agora como definir uma classe em Python e usar um objeto desta classe em um programa. Veja o trecho de código abaixo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# Definição da classe Cliente 
class Cliente:
  "Minha primeira classe Python"
  # define a propriedade nome
  _nome = None
 
  # um método que permite definir o nome do cliente
  def definir_nome(self, nome):
    self._nome = nome
 
  # um método que permite obter o nome do cliente
  def obter_nome(self):
    return self._nome
# Fim da definição da classe Cliente
 
def main():
  # Cria uma instância da classe Cliente
  cliente = Cliente()
 
  # Define o nome do cliente
  cliente.definir_nome("Osmar J. Silva")
 
  # Obtém o nome do cliente
  print(cliente.obter_nome())

if __name__== "__main__":
  main()

Em mais dicas dessa seção você aprenderá mais sobre a programação orientada a objeto em Python.


Desafios, Exercícios e Algoritmos Resolvidos de Python

Veja mais Dicas e truques de Python

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2024 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 64 usuários muito felizes estudando em nosso site.