diff --git a/tutorials/wcs-celestial-coords1/celestial_coords1.ipynb b/tutorials/wcs-celestial-coords1/celestial_coords1.ipynb index 60858366..53db7fb8 100644 --- a/tutorials/wcs-celestial-coords1/celestial_coords1.ipynb +++ b/tutorials/wcs-celestial-coords1/celestial_coords1.ipynb @@ -3,41 +3,42 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "UrWJ4QBTJRsv" }, "source": [ - "# Working with Celestial Coordinates in WCS 1: Specifying, reading, and plotting\n", + "# Trabalhando com coordenadas celestes no WCS 1: Especificando, lendo e plotando\n", "\n", - "## Authors\n", + "## Autores\n", "\n", "Kris Stern, Kelle Cruz, Lia Corrales, David Shupe, Adrian Price-Whelan\n", "\n", - "## Learning Goals\n", + "## Tradução\n", "\n", - "1. Demonstrate two ways to build a `astropy.wcs.WCS` object\n", - "2. Show an image of the Helix nebula with RA and Dec labeled\n", - "3. Plot a scale bar on an image with WCS information\n", + "Josué Cavalcante\n", "\n", - "## Keywords\n", + "## Objetivos de aprendizagem\n", "\n", - "WCS, coordinates, matplotlib\n", + "1. Demonstrar duas maneiras de construir o objeto `astropy.wcs.WCS`\n", + "2. Mostre uma imagem da nebulosa Helix com RA e DEC rotulados\n", + "3. Plotar uma escala de barras em uma imagem com informações WCS\n", "\n", - "## Companion Contents\n", + "## Palavras chaves\n", + "\n", + "WCS, coordenadas, matplotlib\n", + "\n", + "## Conteúdo complementar\n", "1. \"An Introduction to Modern Astrophysics\" ([Carroll & Ostlie](https://ui.adsabs.harvard.edu/abs/2006ima..book.....C/abstract))\n", "2. [FITS WCS page at GSFC](https://fits.gsfc.nasa.gov/fits_wcs.html)\n", "\n", - "## Summary\n", + "## Sumário\n", "\n", - "This tutorial series aims to show how the content of Chapter 1 of \"An Introduction to Modern Astrophysics\" by Carroll and Ostlie can be applied to real life astrophysics research situations, using tools in the Astropy ecosystem. We will introduce two different approaches to building a `astropy.wcs.WCS` object, which contains meta-data that (in this case) defines a mapping between image coordinates and sky coordinates. The `astropy.wcs` subpackage conforms to the standards of the FITS World Coordinate System (WCS) used extensively by the astronomy research community. We will created a 2D WCS for an image of the iconic the Helix nebula (a planetary nebula) and display an image of the nebula with sky coordinates (here, equatorial, ICRS RA and Dec.) labeled. Finally, we will over-plot a scale bar on the Helix nebula image using WCS to give the reader a sense of the angular size of the image." + "Esta série de tutoriais tem como objetivo mostrar como o conteúdo do Capítulo 1 de \"An Introduction to Modern Astrophysics\" de Carroll e Ostlie pode ser aplicado a situações de pesquisa em astrofísica da vida real, usando ferramentas do ecossistema Astropy. Apresentaremos duas abordagens diferentes para construir um objeto `astropy.wcs.WCS`, que contém metadados que (neste caso) definem um mapeamento entre as coordenadas da imagem e as coordenadas do céu. O subpacote `astropy.wcs` está em conformidade com os padrões do FITS World Coordinate System (WCS) usado extensivamente pela comunidade de pesquisa em astronomia. Criaremos um WCS 2D para uma imagem da icônica nebulosa Helix (uma nebulosa planetária) e exibiremos uma imagem da nebulosa com as coordenadas do céu (aqui, equatorial, ICRS RA e Dec) rotuladas. Finalmente, sobreporemos uma barra de escala na imagem da nebulosa Helix usando WCS para dar ao leitor uma noção do tamanho angular da imagem." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": {}, - "colab_type": "code", "id": "ApMUBsVVJRsw" }, "outputs": [], @@ -50,56 +51,51 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "AbDZ0uWTJRsz" }, "source": [ - "## Section 1: Two ways to create an `astropy.wcs.WCS` object\n", - "\n", - "*World coordinates* serve to locate a measurement in some multi-dimensional parameter space. A World Coordinate System (WCS) specifies the physical, or world, coordinates to be attached to each pixel or voxel of an N-dimensional image or array. An [elaborate set of standards and conventions](https://fits.gsfc.nasa.gov/fits_wcs.html) have been developed for the Flexible Image Transport System (FITS) format ([Wells et al. 1981](https://ui.adsabs.harvard.edu/abs/1981A&AS...44..363W/abstract)). A typical WCS example is to specify the Right Ascension (RA) and Declination (Dec) on the sky associated with a given the pixel or spaxel location in a 2-dimensional celestial image ([Greisen & Calabretta 2002](https://ui.adsabs.harvard.edu/abs/2002A&A...395.1061G/abstract); [Calabretta and Greisen 2002](https://ui.adsabs.harvard.edu/abs/2002A&A...395.1077C/abstract)).\n", + "## Seção 1: Duas maneiras de criar um objeto `astropy.wcs.WCS`\n", "\n", - "The [`astropy.wcs` subpackage](https://docs.astropy.org/en/stable/wcs/) implements FITS standards and conventions for World Coordinate Systems. Using the `astropy.wcs.WCS` object and `matplotlib`, we can generate images of the sky that have axes labeled with coordinates such as right ascension (RA) and declination (Dec). This requires selecting the proper projections for `matplotlib` and providing an `astropy.visualization.WCSAxes` object.\n", + "*Coordenadas mundiais* servem para localizar uma medição em algum espaço de parâmetros multidimensional. Um Sistema de Coordenadas Mundiais (WCS) especifica as coordenadas físicas, ou mundiais, a serem anexadas a cada pixel ou voxel de uma imagem ou matriz N-dimensional. Um [conjunto elaborado de padrões e convenções](https://fits.gsfc.nasa.gov/fits_wcs.html) foi desenvolvido para o formato Flexible Image Transport System (FITS) ([Wells et al. 1981](https: //ui.adsabs.harvard.edu/abs/1981A&AS...44..363W/abstract)). Um exemplo típico do WCS é especificar a Ascensão Reta (RA) e a Declinação (Dec) no céu associada a uma determinada localização de pixel ou spaxel em uma imagem celestial bidimensional ([Greisen & Calabretta 2002](https://ui .adsabs.harvard.edu/abs/2002A&A...395.1061G/abstract); [Calabretta e Greisen 2002](https://ui.adsabs.harvard.edu/abs/2002A&A...395.1077C/abstract)) .\n", "\n", - "There are two main ways to initialize a `WCS` object: with a Python dictionary (or dictionary-like object, like a FITS file header) or with Python lists. In this set of examples, we will initialize an `astropy.wcs.WCS` object with two dimensions, as would be needed to represent an image.\n", + "O [subpacote `astropy.wcs`](https://docs.astropy.org/en/stable/wcs/) implementa padrões e convenções FITS para Sistemas de Coordenadas Mundiais. Usando o objeto `astropy.wcs.WCS` e `matplotlib`, podemos gerar imagens do céu que possuem eixos rotulados com coordenadas como ascensão reta (RA) e declinação (Dec). Isso requer selecionar as projeções apropriadas para `matplotlib` e fornecer um objeto `astropy.visualization.WCSAxes`.\n", "\n", - "The WCS standard defines a set of keywords that are used to represent the world coordinate system for a given set of data (e.g., image). Here is a list of the essential WCS keywords and their uses; In each case, the integer $n$ denotes the dimensional axis (starting with 1) to which the keyword is being applied. In our examples below, we will have two image dimensions (axes), so $n$ will either be 1 or 2.\n", + "Existem duas maneiras principais de inicializar um objeto `WCS`: com um dicionário Python (ou objeto semelhante a um dicionário, como um cabeçalho de arquivo FITS) ou com listas Python. Neste conjunto de exemplos, inicializaremos um objeto `astropy.wcs.WCS` com duas dimensões, como seria necessário para representar uma imagem.\n", "\n", - "* **CRVALn**: the coordinate value at a reference point (e.g., RA and DEC value in degrees)\n", - "* **CRPIXn**: the pixel location of the reference point (e.g., CRPIX1=1, CRPIX2=1 describes the center of a corner pixel)\n", - "* **CDELTn**: the coordinate increment at the reference point (e.g., the difference in 'RA' value from the reference pixel to its neighbor along the RA axis)\n", - "* **CTYPEn**: an 8-character string describing the axis type (e.g., 'RA---TAN' and 'DEC---TAN' describe the typical tangent-plane sky projection that astronomers use)\n", - "* **CUNITn**: a string describing the unit for each axis (if not specified, the default unit is degrees.)\n", - "* **NAXISn**: an integer defining the number of pixels in each axis\n", + "O padrão WCS define um conjunto de palavras-chave que são usadas para representar o sistema de coordenadas mundiais para um determinado conjunto de dados (por exemplo, imagem). Aqui está uma lista das palavras-chave essenciais do WCS e seus usos; Em cada caso, o inteiro $n$ denota o eixo dimensional (começando com 1) ao qual a palavra-chave está sendo aplicada. Em nossos exemplos abaixo, teremos duas dimensões de imagem (eixos), então $n$ será 1 ou 2.\n", + "* **CRVALn**: o valor da coordenada em um ponto de referência (por exemplo, valor RA e DEC em graus)\n", + "* **CRPIXn**: a localização do pixel do ponto de referência (por exemplo, CRPIX1=1, CRPIX2=1 descreve o centro de um pixel de canto)\n", + "* **CDELTn**: o incremento de coordenadas no ponto de referência (por exemplo, a diferença no valor 'RA' do pixel de referência para seu vizinho ao longo do eixo RA)\n", + "* **CTYPEn**: uma sequência de 8 caracteres que descreve o tipo de eixo (por exemplo, 'RA---TAN' e 'DEC---TAN' descrevem a projeção do céu do plano tangente típica que os astrônomos usam)\n", + "* **CUNITn**: uma string descrevendo a unidade para cada eixo (se não for especificada, a unidade padrão é graus.)\n", + "* **NAXISn**: um inteiro que define o número de pixels em cada eixo\n", "\n", - "Some good references of the WCS standard can be found [here](https://fits.gsfc.nasa.gov/fits_wcs.html)." + "Algumas boas referências do padrão WCS podem ser encontradas [aqui](https://fits.gsfc.nasa.gov/fits_wcs.html)." ] }, { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "A_uD9fzbUlet" }, "source": [ - "### Method 1: Building a WCS object with a dictionary\n", + "### Método 1: Construindo um objeto WCS com um dicionário\n", "\n", - "One way to define an Astropy `WCS` object is to construct a dictionary containing all of the essential information (i.e., specifying values for the WCS keywords listed above) that map the pixel coordinate space to the world coordinate space. \n", + "Uma maneira de definir um objeto Astropy `WCS` é construir um dicionário contendo todas as informações essenciais (ou seja, especificando valores para as palavras-chave WCS listadas acima) que mapeiam o espaço de coordenadas de pixel para o espaço de coordenadas mundiais.\n", "\n", - "In this example, we define two coordinate axes with:\n", - "* A Gnomonic (tangent-plane) projection, which corresponds to the RA/Dec coordinate system\n", - "* A reference location of (RA,DEC) = (337.52, -20.83), as defined by the **CRVALn** keys\n", - "* The pixel at coordinate value (1,1) as the reference location (**CRPIXn** keys)\n", - "* Units of degrees (**CUNITn = 'deg'**)\n", - "* Pixel sizes of 1 x 1 arcsec (**CDELTn = 0.002778** in degrees)\n", - "* An image size of 1024 x 1024 pixels (**NAXISn** key)" + "Neste exemplo, definimos dois eixos de coordenadas com:\n", + "* Uma projeção Gnomônica (plano tangente), que corresponde ao sistema de coordenadas RA/Dec\n", + "* Um local de referência de (RA,DEC) = (337,52, -20,83), conforme definido pelas chaves **CRVALn**\n", + "* O pixel no valor da coordenada (1,1) como local de referência (chaves **CRPIXn**)\n", + "* Unidades de graus (**CUNITn = 'deg'**)\n", + "* Tamanhos de pixel de 1 x 1 segundo de arco (**CDELTn = 0,002778** em graus)\n", + "* Um tamanho de imagem de 1024 x 1024 pixels (chave **NAXISn**)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": {}, - "colab_type": "code", "id": "3fRBbYmbJRs0" }, "outputs": [], @@ -124,24 +120,17 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "AA4wMjYqJRs2" }, "source": [ - "Now let's print the `WCS` object defined with a Python dictionary to check its content: " + "Agora vamos imprimir o objeto `WCS` definido com um dicionário Python para verificar seu conteúdo:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 194 - }, - "colab_type": "code", - "id": "_3_wPImmJRs3", - "outputId": "7629004b-9897-4c94-e681-1217fa8dcfb5" + "id": "_3_wPImmJRs3" }, "outputs": [], "source": [ @@ -150,29 +139,28 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "id": "bP4tySTaWcgx" + }, "source": [ - "In this demonstration (and below), we assume that we know all of the relevant WCS keyword values to specify. Typically, however, we will rely on software to produce these values for us. For example, WCS information is most often included automatically in FITS files produced by software used to take images with most instruments at astronomical observatories. In cases when the WCS information is provided for us in a FITS file, it is typically included in a FITS header, which, when read into Python, acts like a dictionary object. We demonstrate this later on in this tutorial." + "Nesta demonstração (abaixo), assumimos que conhecemos todos os valores de palavras-chave relevantes do WCS a serem especificados. Normalmente, no entanto, contaremos com software para produzir esses valores para nós. Por exemplo, as informações WCS são mais frequentemente incluídas automaticamente em arquivos FITS produzidos por software usado para tirar imagens com a maioria dos instrumentos em observatórios astronômicos. Nos casos em que as informações do WCS são fornecidas para nós em um arquivo FITS, elas normalmente são incluídas em um cabeçalho FITS, que, quando lido em Python, atua como um objeto de dicionário. Demonstramos isso mais adiante neste tutorial." ] }, { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "YlwK4xHQU6Un" }, "source": [ - "### Method 2: Create an empty WCS object before assigning values\n", + "### Método 2: Crie um objeto WCS vazio antes de atribuir valores\n", "\n", - "Alternatively, we could initialize the `astropy.wcs.WCS` object, and assign the keyword values with lists corresponding to each respective axis." + "Alternativamente, poderíamos inicializar o objeto `astropy.wcs.WCS` e atribuir os valores da palavra-chave com listas correspondentes a cada eixo respectivo." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": {}, - "colab_type": "code", "id": "bGI2DpWdJRs6" }, "outputs": [], @@ -188,24 +176,17 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "ZjCbtC-bAtMr" }, "source": [ - "Let's print the `WCS` object one more time to check how our values were assigned." + "Vamos imprimir o objeto `WCS` mais uma vez para verificar como nossos valores foram atribuídos." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 194 - }, - "colab_type": "code", - "id": "iwx8iECxJRs8", - "outputId": "d8a4818f-13b0-433f-d17d-f660e207ba4c" + "id": "iwx8iECxJRs8" }, "outputs": [], "source": [ @@ -215,19 +196,16 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "rL7-Qut6AGDM" }, "source": [ - "Note that when we initialize the WCS object this way, the `NAXIS` values are set to 0. To assign coordinates to our image, we will need to fix the shape of the `WCS` object array so that it matches our image. We can do this by assigning a value to the `array_shape` attribute of the `WCS` object:" + "Observe que quando inicializamos o objeto WCS desta forma, os valores `NAXIS` são definidos como 0. Para atribuir coordenadas à nossa imagem, precisaremos corrigir a forma do array de objetos `WCS` para que corresponda à nossa imagem. Podemos fazer isso atribuindo um valor ao atributo `array_shape` do objeto `WCS`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": {}, - "colab_type": "code", "id": "6PnSCW0_-pQs" }, "outputs": [], @@ -238,24 +216,17 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "AszZGXxNBDoz" }, "source": [ - "Now when we print the `WCS` object, we can see that the `NAXIS` values have been updated from the default size of 0 to 1024." + "Agora, quando imprimimos o objeto `WCS`, podemos ver que os valores `NAXIS` foram atualizados do tamanho padrão de 0 a 1024." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 194 - }, - "colab_type": "code", - "id": "qdg6jLCa_Sck", - "outputId": "8285ba5c-10e8-457f-bded-15c3faff782c" + "id": "qdg6jLCa_Sck" }, "outputs": [], "source": [ @@ -265,25 +236,22 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "qKvxquTdEOo5" }, "source": [ - "## Section 2: Show an image of the Helix nebula with RA and Dec labeled\n", + "## Seção 2: Mostre uma imagem da nebulosa Helix com RA e Dec rotulados\n", "\n", - "Most of the time we can obtain the required `astropy.wcs.WCS` object from the header of the FITS file from a telescope or astronomical database. This process is described below.\n", + "Na maioria das vezes, podemos obter o objeto `astropy.wcs.WCS` necessário do cabeçalho do arquivo FITS de um telescópio ou banco de dados astronômico. Este processo é descrito abaixo.\n", "\n", - "### Step 1: Read in the FITS file\n", + "### Passo 1: Leia o arquivo FITS\n", "\n", - "We will read the FITS file containing an image of the Helix nebula from the `astropy-data` GitHub repository using the `astropy.io.fits` subpackage. The `astropy.io.fits.open()` function will load the contents of a FITS file into Python, and it accepts either a local file path or a URL (as is demonstrated here). This image (FITS file) was originally accessed from the [Digitized Sky Survey](https://archive.eso.org/dss/dss) but is provided in the `astropy-data` repository for convenience:" + "Vamos ler o arquivo FITS contendo uma imagem da nebulosa Helix do repositório `astropy-data` GitHub usando o subpacote `astropy.io.fits`. A função `astropy.io.fits.open()` carregará o conteúdo de um arquivo FITS no Python e aceita um caminho de arquivo local ou uma URL (como demonstrado aqui). Esta imagem (arquivo FITS) foi originalmente acessada do [Digitized Sky Survey](https://archive.eso.org/dss/dss), mas é fornecida no repositório `astropy-data` por conveniência:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": {}, - "colab_type": "code", "id": "MRVbLwvcE__Y" }, "outputs": [], @@ -294,24 +262,17 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "tTKAPz2pJzH0" }, "source": [ - "FITS files are a binary file format that is mainly used by astronomers and can contain information arranged in many \"extensions,\" which contain both header information (e.g., metadata) and data (e.g., image data). We can check how many extensions there are in a FITS file, as well as view a summary of the contents in each extension, by printing the FITS object information." + "Os arquivos FITS são um formato de arquivo binário usado principalmente por astrônomos e podem conter informações organizadas em muitas \"extensões\", que contêm informações de cabeçalho (por exemplo, metadados) e dados (por exemplo, dados de imagem). Podemos verificar quantas extensões existem em um arquivo FITS, bem como visualizar um resumo do conteúdo de cada extensão, imprimindo as informações do objeto FITS." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 70 - }, - "colab_type": "code", - "id": "n5T4-QCzJVKa", - "outputId": "f7cb2735-6c58-44b3-a965-bd297e2bfc10" + "id": "n5T4-QCzJVKa" }, "outputs": [], "source": [ @@ -321,19 +282,16 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "we-RjJ8PJo1w" }, "source": [ - "This shows us that our FITS file contains only one extension, labeled 'PRIMARY' (or extension number 0). We will copy the image data from this extension to the variable `image`, and the header data to the variable `header`:" + "Isso nos mostra que nosso arquivo FITS contém apenas uma extensão, rotulada 'PRIMARY' (ou extensão número 0). Copiaremos os dados da imagem desta extensão para a variável `image`, e os dados do cabeçalho para a variável `header`:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": {}, - "colab_type": "code", "id": "w4W_HiR-Ji6g" }, "outputs": [], @@ -345,24 +303,17 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "EUVTT2WdKCGd" }, "source": [ - "We can print the FITS image header to screen so that all of its contents can be checked or utilized. Note that the WCS information for this information can be found near the bottom of the printed header, below." + "Podemos imprimir o cabeçalho da imagem FITS na tela para que todo o seu conteúdo possa ser verificado ou utilizado. Observe que as informações do WCS para essas informações podem ser encontradas na parte inferior do cabeçalho impresso, abaixo." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "colab_type": "code", - "id": "XcerK_cZJ30W", - "outputId": "f609c0ae-0116-45c6-fd89-921a208c9434" + "id": "XcerK_cZJ30W" }, "outputs": [], "source": [ @@ -372,31 +323,27 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "g3FyYZ-bQ5b7" }, "source": [ - "Please note that the *original* header (as downloaded from the DSS) violates the FITS WCS standards (because it includes both CDELTn keywords and a matrix of CD values; including deprecated PC-matrix keywords). The header has been cleaned up to conform to the existing standards." + "Observe que o cabeçalho *original* (conforme baixado do DSS) viola os padrões FITS WCS (porque inclui palavras-chave CDELTn e uma matriz de valores de CD; incluindo palavras-chave de matriz PC obsoletas). O cabeçalho foi limpo para estar em conformidade com os padrões existentes." ] }, { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "FzAtb_LWLyWn" }, "source": [ - "### Step 2: Read in the FITS image coordinate system with astropy.wcs.WCS\n", + "### Etapa 2: Leia no sistema de coordenadas da imagem FITS com astropy.wcs.WCS\n", "\n", - "Because the header contains WCS information and acts like a Python dictionary, an Astropy `WCS` object can be created directly from the FITS header." + "Como o cabeçalho contém informações WCS e age como um dicionário Python, um objeto Astropy `WCS` pode ser criado diretamente do cabeçalho FITS." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": {}, - "colab_type": "code", "id": "3Wl5J0HBLoIp" }, "outputs": [], @@ -407,24 +354,17 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "Akv472vTZFLp" }, "source": [ - "Let's print the `WCS` object to see what values were drawn from the header." + "Vamos imprimir o objeto `WCS` para ver quais valores foram extraídos do cabeçalho." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 194 - }, - "colab_type": "code", - "id": "1C7y709IZNvl", - "outputId": "6aee1d99-9f6f-4990-ef55-aa601c33ff0d" + "id": "1C7y709IZNvl" }, "outputs": [], "source": [ @@ -434,19 +374,20 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "O10H9rmtQEnM" }, "source": [ - "### Step 3: Plot the Helix nebula with sky coordinate axes (RA and Dec)\n", + "### Etapa 3: Plote a nebulosa Helix com eixos de coordenadas do céu (RA e DEC)\n", "\n", - "The image data, `image`, is a 2D array of values, and by itself contains no information about the sky coordinates of the pixels. So, if we plotted the image by itself, the plot axes would show pixel values. (We will be using the `matplotlib` library for the plotting.)" + "Os dados da imagem, `image`, são uma matriz 2D de valores e, por si só, não contêm informações sobre as coordenadas do céu dos pixels. Assim, se plotarmos a imagem por si só, os eixos de plotagem mostrariam valores de pixel. (Estaremos usando a biblioteca `matplotlib` para a plotagem.)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": {}, + "metadata": { + "id": "gV0MXRKrWchC" + }, "outputs": [], "source": [ "fig = plt.figure(figsize=(10, 10))\n", @@ -455,22 +396,18 @@ }, { "cell_type": "markdown", - "metadata": {}, + "metadata": { + "id": "7F8oKtmyWchD" + }, "source": [ - "All of the information that maps from these pixel values to sky coordinates comes from the WCS metadata, which we loaded into the `wcs_helix` object (from the FITS file header). This `WCS` object is built so that it can be provided to `matplotlib` with the `projection` keyword, as shown in the call to `matplotlib.pyplot.subplot` below, in order to produce axes that show sky coordinate information instead of pixel values. We will also overlay a coordinate grid in ICRS equatorial coordinates by passing the sky coordinate frame name (here, \"icrs\") to the `ax.get_coords_overlay()` method." + "Todas as informações que mapeiam esses valores de pixel para as coordenadas do céu vêm dos metadados WCS, que carregamos no objeto `wcs_helix` (do cabeçalho do arquivo FITS). Este objeto `WCS` é construído para que possa ser fornecido ao `matplotlib` com a palavra-chave `projection`, como mostrado na chamada para `matplotlib.pyplot.subplot` abaixo, a fim de produzir eixos que mostrem informações de coordenadas do céu. de valores de pixel. Também sobreporemos uma grade de coordenadas em coordenadas equatoriais ICRS passando o nome do quadro de coordenadas do céu (aqui, \"icrs\") para o método `ax.get_coords_overlay()`." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 607 - }, - "colab_type": "code", - "id": "fnv48KDbOkxB", - "outputId": "05775d9a-6663-4b01-a3d3-0d7c9440ea64" + "id": "fnv48KDbOkxB" }, "outputs": [], "source": [ @@ -487,26 +424,19 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "DVVT552iQYn4" }, "source": [ - "## Exercise\n", + "## Exercício\n", "\n", - "Copy the code block above and instead overlay a coordinate grid in Galactic coordinates." + "Copie o bloco de código acima e, em vez disso, sobreponha uma grade de coordenadas em coordenadas galácticas." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 610 - }, - "colab_type": "code", - "id": "XPA-2LOLQLnB", - "outputId": "7eb7e024-b8a7-4d16-b0c3-0a1aa7c71d39" + "id": "XPA-2LOLQLnB" }, "outputs": [], "source": [ @@ -523,32 +453,25 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "FexGrb2hXj85" }, "source": [ - "## Section 3: Plot a scale marker on an image with WCS\n", + "## Seção 3: Plote um marcador de escala em uma imagem com WCS\n", "\n", - "To add a scale marker (i.e., a line of a particular *angular* size) to the image of the Helix nebula, we will use the matplotlib `Axes.arrow` method to draw a line. \n", + "Para adicionar um marcador de escala (ou seja, uma linha de um tamanho *angular* específico) à imagem da nebulosa Helix, usaremos o método matplotlib `Axes.arrow` para desenhar uma linha.\n", "\n", - "First, we need to decide where to place the scale bar. In the example below, we define the center of the scale marker to be at `(RA, Dec) = (337 deg, -21.2 deg)`. \n", + "Primeiro, precisamos decidir onde colocar a barra de escala. No exemplo abaixo, definimos o centro do marcador de escala em `(RA, Dec) = (337 graus, -21,2 graus)`.\n", "\n", - "We then use the `transform` attribute of `Axes.arrow` to draw our scale bars in degrees (instead of pixel coordinates). In this case, we draw a scale marker with a length of 0.1 degrees. The arrow method inputs are `ax.arrow(x, y, dx, dy, **kwargs)`, with `x` and `y` being the `RA` and `Dec` of the beginning of the line. We use `dx=0` so that there is no horizontal component in the bar, and `dy=0.1`, which gives the length of the arrow in the vertical direction. To ensure that the arrow is drawn in the J2000 ICRS coordinate frame, we pass `ax.get_transform('icrs')` to the `transform` keyword.\n", + "Em seguida, usamos o atributo `transform` de `Axes.arrow` para desenhar nossas barras de escala em graus (em vez de coordenadas de pixel). Nesse caso, desenhamos um marcador de escala com um comprimento de 0,1 graus. As entradas do método de seta são `ax.arrow(x, y, dx, dy, **kwargs)`, com `x` e `y` sendo o `RA` e o `Dec` do início da linha. Usamos `dx=0` para que não haja componente horizontal na barra, e `dy=0.1`, que dá o comprimento da seta na direção vertical. Para garantir que a seta seja desenhada no quadro de coordenadas J2000 ICRS, passamos `ax.get_transform('icrs')` para a palavra-chave `transform`.\n", "\n", - "Finally, we use `matplotlib.pyplot.text` to mark the length of the scale marker." + "Finalmente, usamos `matplotlib.pyplot.text` para marcar o comprimento do marcador de escala." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 607 - }, - "colab_type": "code", - "id": "OkH12BWESpGp", - "outputId": "adcffc9d-85fb-45f2-e38a-11f18db320d7" + "id": "OkH12BWESpGp" }, "outputs": [], "source": [ @@ -569,21 +492,18 @@ { "cell_type": "markdown", "metadata": { - "colab_type": "text", "id": "N_CWLccBPXvu" }, "source": [ - "## Exercise\n", + "## Exercício\n", "\n", - "Make a horizontal bar with the same length. Keep in mind that 1 hour angle = 15 degrees." + "Faça uma barra horizontal com o mesmo comprimento. Tenha em mente que o ângulo de 1 hora = 15 graus." ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "colab": {}, - "colab_type": "code", "id": "bIePbBar8uFv" }, "outputs": [], @@ -591,6 +511,10 @@ } ], "metadata": { + "colab": { + "name": "celestial_coords1.ipynb", + "provenance": [] + }, "language_info": { "codemirror_mode": { "name": "ipython", @@ -604,5 +528,5 @@ } }, "nbformat": 4, - "nbformat_minor": 4 + "nbformat_minor": 0 }