画1维光栅能带的Python拓展

最新推荐文章于 2024-06-03 08:15:00 发布
最新推荐文章于 2024-06-03 08:15:00 发布
阅读量724 收藏
点赞数 1
分类专栏： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40267373/article/details/110008523
版权

画1维光栅能带的Python拓展

最近因为无法忍受Python运行效率的低下，但又不想放弃Python，于是用C语言写了一个Python画一维光栅能带和薄膜干涉的拓展。

代码

改了很多遍，终于改出了自己想要的编程风格，等以后自己编程风格变了，再回来把它改了。

plotBand.h

/**********************************************************************************************************************
*   File Name               :   plotBand.h
*   Copyright               :   2020-2025 Fudan University, All Rights Reserved.
*   Module Name             :   plotBand
*
*   CPU                     :   16  Intel(R) Core(TM) i7-10700F CPU @ 2.90GHz
*   OS                      :   Ubuntu
*
*   Create Date             :   2020/11/23
*   Author/Corporation      :   Lingjie Fan/Fudan University
*
*   Abstract Description    :   Some declarations of struct and function used to plot band of grating are contained
*                               in this file.
*
*--------------------------------------------------------------------------------------------------------------------
*   Revision History
*   No  Version     Date        Revised By      Item                            Description
*   1   V1.0.0      2020/11/23  Lingjie Fan     Header File Header Section      Description and record are added
*   2   V1.0.0      2020/11/23  Lingjie Fan     Macro Define Section            Macro EPSILON is defined
*   3   V1.0.0      2020/11/23  Lingjie Fan     Prototype Declare Section       Two private function is moved from
*                                                                               header file to source file
*   4   V1.0.0      2020/11/25  Lingjie Fan     Structure Define Section        "typedef" is used for simplify
*   5   V2.0.0      2020/11/25  Lingjie Fan     Structure Define Section        In order to calculate the band with
*                                                                               dispersion, Two struct and function
*                                                                               is added
*   6   V2.0.0      2020/11/26  Lingjie Fan     Structure Define Section        struct _Band and _Interference is delete
*
***********************************************************************************************************************/

#ifndef _PLOT_BAND_H_
#define _PLOT_BAND_H_

#define PI 3.1415926
#define NO_SOLUTION -100.
#define EPSILON 1E-3

typedef struct _Grating
{
    float a; /*Period of grating*/
    float d; /*Thickness of grating*/
    float f; /*Duty cycle of grating*/
    float n1; /*Refractive index of Air*/
    float n2; /*Refractive index of Grating*/
    float n3; /*Refractive index of Substrate*/
}Grating;

typedef struct _BandAtOmega
{
	float *k;
	float omega;
	float *Z;
	int size;
	int isTE;
	int order;
}BandAtOmega;

typedef struct _InterferenceAtOmega
{
	float k;
	float omega;
	int order;
}InterferenceAtOmega;

extern void solveFilmAtOmega(Grating *pGrating, InterferenceAtOmega *pInterferenceAtOmega);

extern void solveBandAtOmega(Grating *pGrating, BandAtOmega *pBandAtOmega);

#endif /*_PLOT_BAND_H_*/

plotBand.c

/**********************************************************************************************************************
*   File
*   File Name               :   plotBand.c
*   Copyright               :   2020-2025 Fudan University, All Rights Reserved.
*   Module Name             :   plotBand
*
*   CPU                     :   16  Intel(R) Core(TM) i7-10700F CPU @ 2.90GHz
*   OS                      :   Ubuntu
*
*   Create Date             :   2020/11/23
*   Author/Corporation      :   Lingjie Fan/Fudan University
*
*   Abstract Description    :   Some functions used to plot band of grating are implemented in this file.
*
*----------------------------------------------------------------------------------------------------------------------
*    Function
*    Function1 Name              :    solveFilm
*    Create Time                 :    2020/11/23
*    Description                 :    Calculate the extreme point of the film interference, change the property omega
*                                     in struct _Interference
*    Param                       :    pGrating: the pointer of struct _Grating
*                                     pInterference: the pointer of struct _Interference
*    Return Code                 :    void: only change the property omega in struct _Interference
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*
*    Function2 Name              :    bandEquation
*    Create Time                 :    2020/11/23
*    Description                 :    Calculate the band at point (omega, k)
*    Param                       :    pGrating: the pointer of struct _Grating
*                                     k: the wave vector
*                                     omega: the angular frequency
*                                     isTE: whether the band is TE, 0 for TM, 1 for TE.
*                                     order: the order of the band
*    Return Code                 :    creal(l1+l2+l3): if the point (omega, k) is at the band
*                                     NO_SOLUTION: if the point is out of the band
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*
*    Function3 Name              :    solveBand
*    Create Time                 :    2020/11/23
*    Description                 :    Calculate the band of the 1D grating
*    Param                       :    pGrating: the pointer of struct _Grating
*                                     pBand: the pointer of struct _Band
*    Return Code                 :    void: only change the property Z in struct _Band
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*
*    Function4 Name              :    solveFilmAtOmega
*    Create Time                 :    2020/11/25
*    Description                 :    Calculate the film interference of the 1D grating at a omega
*    Param                       :    pGrating: the pointer of struct _Grating
*                                     pInterferenceAtOmega: the pointer of struct _InterferenceAtOmega
*    Return Code                 :    void: only change the property k in struct _InterferenceAtOmega
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*
*    Function5 Name              :    solveBandAtOmega
*    Create Time                 :    2020/11/25
*    Description                 :    Calculate the band of the 1D grating at a omega
*    Param                       :    pGrating: the pointer of struct _Grating
*                                     pBandAtOmega: the pointer of struct _BandAtOmega
*    Return Code                 :    void: only change the property k in struct _BandAtOmega
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*
*---------------------------------------------------------------------------------------------------------------------
*   Revision History
*   No  Version     Date        Revised By      Item                            Description
*   1   V1.0.0      2020/11/23  Lingjie Fan     Source File Header Section      Description and record are added
*   2   V1.0.0      2020/11/23  Lingjie Fan     Function Define Section         Word "register" is used for loop vars
*   3   V1.0.0      2020/11/23  Lingjie Fan     Prototype Define Section        Two private functions are moved from
*                                                                               header file to source file
*   4   V1.0.0      2020/11/24  Lingjie Fan     Macro Define Section            Function nEff is replaced by Macro NEFF
*   5   V1.0.0      2020/11/24  Lingjie Fan     Function Define Section         In order to become faster, "pow(,2)" is
*                                                                               replace by "*"
*   6   V1.0.0      2020/11/25  Lingjie Fan     Function Define Section         In order to become faster, function fabs
*                                                                               is replaced by Macro FABS.
*   7   V2.0.0      2020/11/25  Lingjie Fan     Function Define Section         Two function is added to consider the
*                                                                               dispersion of material.
*
***********************************************************************************************************************/

#include "plotBand.h"
#include <math.h>
#include <complex.h>

#define NEFF(n1, n2, f) sqrt(((n1) * (n1) * (1-(f))) + ((n2) * (n2) * (f)))
#define FABS(x) (((x)>=0.0)? (x) : -(x))

extern float bandEquation(Grating *pGrating, float k, float omega, int isTE, int order);

void solveFilmAtOmega(Grating *pGrating, InterferenceAtOmega *pInterferenceAtOmega)
{
    float neff;
    float complex k;

    neff = NEFF(pGrating->n1, pGrating->n2, pGrating->f);
    k = csqrt(neff * neff * pInterferenceAtOmega->omega * pInterferenceAtOmega->omega - pInterferenceAtOmega->order *\
        pInterferenceAtOmega->order * pGrating->a * pGrating->a / (4 * 4 * pGrating->d * pGrating->d));
    if(creal(k) < pInterferenceAtOmega->omega)
    {
        pInterferenceAtOmega->k = creal(k);
    }
    else
    {
        pInterferenceAtOmega->k = NO_SOLUTION;
    }
}

float bandEquation(Grating *pGrating, float k, float omega, int isTE, int order)
{
    float neff;
    float complex l1, l2, l3;

    neff = NEFF(pGrating->n1, pGrating->n2, pGrating->f);
    if(isTE)
    {
        l1 = -I * clog((I * csqrt(k * k - pGrating->n1 * pGrating->n1 * omega * omega) - csqrt(-k * k + \
            neff * neff * omega * omega)) / (I * csqrt(k * k - pGrating->n1 * pGrating->n1 * omega * omega) + \
            csqrt(-k * k + neff * neff * omega * omega)));
        l2 = carg((csqrt(-k * k + neff * neff * omega * omega) - csqrt(-k * k + pGrating->n3 * pGrating->n3 * omega * \
            omega)) / (csqrt(-k * k + neff * neff * omega * omega) + csqrt(-k * k + pGrating->n3 * pGrating->n3 * \
            omega * omega)));
    }
    else
    {
        l1 = -I * clog((I * neff * neff * csqrt(k * k - pGrating->n1 * pGrating->n1 * omega * omega) - \
            pGrating->n1 * pGrating->n1 * csqrt(-k * k + neff * neff * omega * omega))/(I * neff * neff * \
            csqrt(k * k - pGrating->n1 * pGrating->n1 * pGrating->n1 * pGrating->n1 * omega * omega) + \
            pGrating->n1 * pGrating->n1 * csqrt(-k * k + neff * neff * omega * omega)));
        l2 = carg((pGrating->n1 * pGrating->n1 * csqrt(-k * k + neff * neff * omega * omega) - \
            neff * neff * csqrt(-k * k + pGrating->n3 * pGrating->n3 * omega * omega))/(neff * neff * csqrt(-k * k + \
            neff * neff * omega * omega) + pGrating->n1 * pGrating->n1 * csqrt(-k * k + pGrating->n3 * pGrating->n3 * \
            omega * omega)));
    }
    l3 = - (2. * order + 1. - 2. * csqrt(-k * k + neff * neff * omega * omega) * 2 * pGrating->d / pGrating->a) * PI;
    if(FABS(cimag(l1+l2+l3)) < EPSILON)
        return creal(l1+l2+l3);
    else
        return NO_SOLUTION;
}

void solveBandAtOmega(Grating *pGrating, BandAtOmega *pBandAtOmega)
{
    register int i;

    for(i=0; i<pBandAtOmega->size; i++)
    {
        *(pBandAtOmega->Z + i) = bandEquation(pGrating, *(pBandAtOmega->k + i), pBandAtOmega->omega, \
            pBandAtOmega->isTE, pBandAtOmega->order);
    }
}

PyplotBand.c

/**********************************************************************************************************************
*    File
*    File Name               :    PyplotBand.c
*    Copyright               :    2020-2025 Fudan University, All Rights Reserved.
*    Module Name             :    plotBand
*
*    CPU                     :    16  Intel(R) Core(TM) i7-10700F CPU @ 2.90GHz
*    OS                      :    Ubuntu
*
*    Create Date             :    2020/11/23
*    Author/Corporation      :    Lingjie Fan/Fudan University
*
*    Abstract Description    :    This file is used to package function in C into the function in python.
*
*----------------------------------------------------------------------------------------------------------------------
*    Function
*    Function1 Name              :    plotBand_solveFilm
*    Create Time                 :    2020/11/23
*    Description                 :    Package C function solveFilm into python function plotBand.solveFilm
*    Param                       :    self: Unknown
*                                     args: The parameters received from python function in python Object which need to
*                                           transform into var in C
*    Return Code                 :    pList: a python list contained the information of omega in struct Interference
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*
*    Function2 Name              :    plotBand_solveBand
*    Create Time                 :    2020/11/23
*    Description                 :    Package C function solveBand into python function plotBand.solveBand
*    Param                       :    self: Unknown
*                                     args: The parameters received from python function in python Object which need to
*                                           transform into var in C
*    Return Code                 :    matrix: A python 2D list contained the information of Z in struct Band
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*
*    Function3 Name              :    plotBand_solveDispFilm
*    Create Time                 :    2020/11/25
*    Description                 :    Package C function solveFilmAtOmega into python function plotBand.solveDispFilm
*    Param                       :    self: Unknown
*                                     args: The parameters received from python function in python Object which need to
*                                           transform into var in C
*    Return Code                 :    pList: a python list contained the information of omega in struct Interference
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*
*    Function4 Name              :    plotBand_solveDispBand
*    Create Time                 :    2020/11/26
*    Description                 :    Package C function solveBandAtOmega into python function plotBand.solveDispBand
*    Param                       :    self: Unknown
*                                     args: The parameters received from python function in python Object which need to
*                                           transform into var in C
*    Return Code                 :    matrix: A python 2D list contained the information of Z in struct Band
*    Global Variable             :    None
*    File Static Variable        :    None
*    Function Static Variable    :    None
*--------------------------------------------------------------------------------------------------------------------
*    Revision History
*    No   Version    Date        Revised By      Item                            Description
*    1    V1.0.0     2020/11/23  Lingjie Fan     Source File Header Section      Description and record are added
*    2    V1.0.0     2020/11/23  Lingjie Fan     Function Define Section         Word "register" is used for loop vars
*    3    V2.0.0     2020/11/25  Lingjie Fan     Function Define Section         Function plotBand_solveDispFilm is
*                                                                                added
*    4    V2.0.0     2020/11/26  Lingjie Fan     Function Define Section         Function plotBand_solveDisBand is added
***********************************************************************************************************************/

#define PY_SSIZE_T_CLEAN
#include <Python.h>
#include <stdio.h>
#include "plotBand.h"

static PyObject *plotBand_solveFilm(PyObject *self, PyObject *args)
{
    register int i;
    int size, order;
    float a, d, f, omegaMin, omegaMax;
    PyObject *Pyn1, *Pyn2, *Pyn3;
    if(!PyArg_ParseTuple(args,"(fffOOO)(ffii)",&a, &d, &f, &Pyn1, &Pyn2, &Pyn3, &omegaMin, &omegaMax, &size, &order))
    {
        return NULL;
    }
    float k, omega, n1, n2, n3, step;
    PyObject *pList = PyList_New(size);
    assert(PyList_Check(pList));
    assert(PyList_Check(Pyn1));
    assert(PyList_Check(Pyn2));
    assert(PyList_Check(Pyn3));

    step = (omegaMax - omegaMin) / size;
    for(i=0;i<size;i++)
    {
        k = 0.0;
        omega = omegaMin + step * i;
        n1 = PyFloat_AsDouble(PyList_GetItem(Pyn1, i));
        n2 = PyFloat_AsDouble(PyList_GetItem(Pyn2, i));
        n3 = PyFloat_AsDouble(PyList_GetItem(Pyn3, i));
        Grating grating={a, d, f, n1, n2, n3};
        InterferenceAtOmega interferenceAtOmega={k, omega, order};
        solveFilmAtOmega(&grating, &interferenceAtOmega);
        if(interferenceAtOmega.k != NO_SOLUTION)
        {
            PyList_SetItem(pList, i, Py_BuildValue("f", interferenceAtOmega.k));
        }
        else
        {
            Py_INCREF(Py_None);
            PyList_SetItem(pList, i, Py_None);
        }
    }
    return pList;
}

static PyObject *plotBand_solveBand(PyObject *self, PyObject *args)
{
    register int i, j;
    int kSize, omegaSize, isTE, order;
    float a, d, f, n1, n2, n3;
    float omega, omegaMax, omegaMin, kMax, kMin, kStep, omegaStep;
    PyObject *Pyn1, *Pyn2, *Pyn3;
    if(!PyArg_ParseTuple(args, "(fffOOO)(ffffiiii)", &a, &d, &f, &Pyn1, &Pyn2, &Pyn3, &kMin, &kMax, &omegaMin, \
            &omegaMax, &kSize, &omegaSize, &isTE, &order))
    {
        return NULL;
    }

    float k[kSize], Z[kSize];
    PyObject *matrix = PyList_New(omegaSize);
    assert(PyList_Check(matrix));
    assert(PyList_Check(Pyn1));
    assert(PyList_Check(Pyn2));
    assert(PyList_Check(Pyn3));

    kStep = (kMax - kMin) / kSize;
    omegaStep = (omegaMax - omegaMin) / omegaSize;
    for(i=0;i<kSize;i++)
    {
        k[i] = kMin + kStep * i;
    }
    for(j=0;j<omegaSize;j++)
    {
        omega = omegaMin + omegaStep * j;
        n1 = PyFloat_AsDouble(PyList_GetItem(Pyn1, j));
        n2 = PyFloat_AsDouble(PyList_GetItem(Pyn2, j));
        n3 = PyFloat_AsDouble(PyList_GetItem(Pyn3, j));
        Grating grating = {a, d, f, n1, n2, n3};
        BandAtOmega bandAtOmega = {k, omega, Z, kSize, isTE, order};
        solveBandAtOmega(&grating, &bandAtOmega);
        PyObject *rowList = PyList_New(kSize);
        assert(PyList_Check(rowList));
        for(i=0;i<kSize;i++)
        {
            if(*(bandAtOmega.Z+i) != NO_SOLUTION)
            {
                PyList_SetItem(rowList, i, Py_BuildValue("f", *(bandAtOmega.Z+i)));
            }
            else
            {
                Py_INCREF(Py_None);
                PyList_SetItem(rowList, i, Py_None);
            }
        }
        PyList_SetItem(matrix,j,rowList);
    }
    return matrix;
}

static PyMethodDef PlotBandMethods[] =
{
    {"solveFilm", plotBand_solveFilm, METH_VARARGS, "Calculate interference of film"},
    {"solveBand", plotBand_solveBand, METH_VARARGS, "Calculate band of grating"},
    {NULL,NULL,0,NULL}
};

static PyModuleDef plotBand =
{
    PyModuleDef_HEAD_INIT,
    "plotBand",
    NULL,
    -1,
    PlotBandMethods
};

PyMODINIT_FUNC PyInit_plotBand(void)
{
    return PyModule_Create(&plotBand);
}

setup.py

from distutils.core import setup, Extension


def main():
    setup(name="plotBand",
          version="1.0.0",
          description="Python interface for plotBand",
          author="lingjie",
          author_email="20210190044@fudan.edu.cn",
          ext_modules=[Extension("plotBand", ["PyplotBand.c", "plotBand.c"])])


if __name__ == "__main__":
    main()

test.py

"""
//
/
/plotBand 接口:
/   1.色散关系设置： n1(list), n2(list), n3(list);
/   类型:list 、自变量 omega，因变量 n1,n2,n3
/   
/   2.光栅设置： grating
/   类型：元组、（周期、高度、占空比、空气折射率（list）、光栅材料折射率（list）、衬底折射率（list））
/
/   3.干涉设置： interference   
/   类型：元组、（omegaMin, omegaMax, omegaSize, 干涉级次）
/
/   4.能带： band
/   类型：元组、（kMin,kMax,omegaMin,omegaMax,kSize,omegaSize,TE/TM： 1 for TE, 0 for TM, 级次（order））
/
/   5.显示设置
/   
/   6.文件
/   w_a_h w/a 
/   第1列 1/lamda 
/   第2列-第52列 p
/   第52列-103列 s
/   k: k_give * a / (2 * pi) k_give range(0,2*pi/(0.4*sin(65)),51)
/   omega: omega_give * a omega_give range(1/0.9,1/0.4,301)
/   光线以下是-1
/
//
"""
import warnings
import plotBand as pltbd
import matplotlib.pyplot as plt
import numpy as np

warnings.filterwarnings("ignore")

# Range Setting
omegaMin = 0.5
omegaMax = 2.0
omegaSize = 150
kMin = 0.0
kMax = 2.0
kSize = 200

# Grating Setting
period = 500
thickness = 300
f = 0.5
n1 = list(np.linspace(1, 1, omegaSize))  
n2 = list(np.linspace(1.4, 1.4, omegaSize))
n3 = list(np.linspace(3.4, 6, omegaSize))

# Show Setting
kMinShow = 0.0
kMaxShow = 2.0
omegaMinShow = 0.5
omegaMaxShow = 2.0

k = np.linspace(kMin, kMax-(kMax-kMin)/kSize, kSize)
omega = np.linspace(omegaMin, omegaMax-(omegaMax-omegaMin)/omegaSize, omegaSize)
grating = (period, thickness, f, n1, n2, n3)

interference1 = (omegaMin, omegaMax, omegaSize, 1)
interference2 = (omegaMin, omegaMax, omegaSize, 2)
interference3 = (omegaMin, omegaMax, omegaSize, 3)
interference4 = (omegaMin, omegaMax, omegaSize, 4)
interference5 = (omegaMin, omegaMax, omegaSize, 5)

TEband1 = (kMin,kMax,omegaMin,omegaMax,kSize,omegaSize, 1, 1)
TEband2 = (kMin,kMax,omegaMin,omegaMax,kSize,omegaSize, 1, 2)
TMband1 = (kMin,kMax,omegaMin,omegaMax,kSize,omegaSize, 0, 1)
TMband2 = (kMin,kMax,omegaMin,omegaMax,kSize,omegaSize, 0, 2)

iResult1 = pltbd.solveFilm(grating, interference1)
iResult2 = pltbd.solveFilm(grating, interference2)
iResult3 = pltbd.solveFilm(grating, interference3)
iResult4 = pltbd.solveFilm(grating, interference4)
iResult5 = pltbd.solveFilm(grating, interference5)
bResult1 = pltbd.solveBand(grating, TEband1)
bResult2 = pltbd.solveBand(grating, TEband2)
bResult3 = pltbd.solveBand(grating, TMband1)
bResult4 = pltbd.solveBand(grating, TMband2)

#light line
plt.plot(omega,omega,color="black")
plt.plot(1-omega,omega,color="black")
plt.plot(omega-1,omega,color="black")
plt.plot(2-omega,omega,color="black")
plt.plot(omega-2,omega,color="black")
plt.plot(3-omega,omega,color="black")

#interference
plt.plot(iResult1,omega)
plt.plot(iResult2,omega)
plt.plot(iResult3,omega)
plt.plot(iResult4,omega)
plt.plot(iResult5,omega)

#band
plt.contour(k,omega,bResult1,[0],colors="red")
plt.contour(k,omega,bResult2,[0],colors="red")
plt.contour(k,omega,bResult3,[0],colors="blue")
plt.contour(k,omega,bResult4,[0],colors="blue")
plt.contour(1-k,omega,bResult1,[0],colors="red")
plt.contour(1-k,omega,bResult2,[0],colors="red")
plt.contour(1-k,omega,bResult3,[0],colors="blue")
plt.contour(1-k,omega,bResult4,[0],colors="blue")
plt.contour(k-1,omega,bResult1,[0],colors="red")
plt.contour(k-1,omega,bResult2,[0],colors="red")
plt.contour(k-1,omega,bResult3,[0],colors="blue")
plt.contour(k-1,omega,bResult4,[0],colors="blue")
plt.contour(2-k,omega,bResult1,[0],colors="red")
plt.contour(2-k,omega,bResult2,[0],colors="red")
plt.contour(2-k,omega,bResult3,[0],colors="blue")
plt.contour(2-k,omega,bResult4,[0],colors="blue")
plt.contour(3-k,omega,bResult1,[0],colors="red")
plt.contour(3-k,omega,bResult2,[0],colors="red")
plt.contour(3-k,omega,bResult3,[0],colors="blue")
plt.contour(3-k,omega,bResult4,[0],colors="blue")

plt.xlim(kMinShow, kMaxShow)
plt.ylim(omegaMinShow, omegaMaxShow)
plt.show()

安装

linux系统上,在该目录下
$ sudo python3 setup.py install
在这里插入图片描述
这个程序 Windows 上安装会提示不能用变量作为数组的长度，但是按照C99标准明明可以这么做。不管了只要linux上的 gcc 不报错就行了。

运行

之后就可以运行 test.py这个测试程序了。
在这里插入图片描述

Lingjie Fan
关注
专栏目录
MATLAB算法实战应用案例精讲-【图像处理】三维重建(附MATLAB和python代码实现)
qq_36130719的博客
12-13 1万+
在计算机视觉中，三维重建是指根据单视图或者多视图图像重建原始三维信息的过程。单视图缺少深度、多视角信息，基于单视图的三维重建效果较一般。基于多视角图像的三维重建，充分利用了多视角拍摄信息，先对摄像机进行标定，并计算出摄像机的图像坐标系与真实世界坐标系的关系，然后利用多个二维图像重建出三维信息。广义上，三维重建是指对某些三维物体或者三维场景的一种恢复和重构。重建出来的模型，方便计算机表示和处理。
Python绘制正余弦函数图像的方法
12-25
今天打算通过绘制正弦和余弦函数，从默认的设置开始，一步一步地调整改进，让它变得好看，变成我们初高中学习过的图象那样。通过这个过程来学习如何进行对图表的一些元素的进行调整。 01. 简单绘图 matplotlib有一套允许定制各种属性的默认设置。你可以几乎控制matplotlib中的每一个默认属性：图像大小，每英寸点数，线宽，色彩和样式，子图(axes)，坐标轴和网格属性，文字和字体属性，等等。 安装 pip install matplotlib 虽然matplotlib的默认设置在大多数情况下相当好，你却可能想要在一些特别的情形下更改一些属性。 from pylab import *
今日又是没有python（预习大物实验 ‘利用光栅衍射法测光波波长’）
weixin_45666838的博客
12-02 630
今天早晚都有课，下午又去搞星期五准备要做的实验的实验预习报告，只是没想到画4个图几个公式 搞了一下午，所以停一天啦，报告被同学借走抄去了，明天再补个图。明天时间比较多，预计明天看完python下一部分后抽时间把大物波动学复习下外加课后习题都做一遍，加油！ ...
使用python生成正弦光栅的代码示例，包括竖直光栅，水平光栅，圆光栅
qq_44318809的博客
05-18 1626
使用python生成正弦光栅的代码示例，包括竖直光栅，水平光栅，圆光栅 import numpy as np import matplotlib.pyplot as plt # from scipy.fftpack import fft,ifft from matplotlib.pylab import mpl mpl.rcParams['font.sans-serif'] = ['SimHei'] #显示中文 mpl.rcParams['axes.unicode_minus']=False
光栅衍射多普勒效应位移测量的理论分析和实验结果
02-13
本文研究了一种利用光栅衍射的多普勒效应进行位移测量的新方法.文中进行了光路结构和测量原理的理论分析,得出测量公式,证明了用光栅拾取多路差拍信号的相位关系.实验结果表明,它具有高的信号质量,可有效地用于位移的精密测量.
Comsol连续体中的束缚态BIC。涉及能带计算与Q因子计算，包含一维光栅和二维光子晶体板
TBpLRCiGnD的博客
03-26 967
通过建立合适的模型和设定参数，利用Comsol的数值模拟工具，我们可以计算和分析束缚态BIC的性质和效应，为光学器件的设计和应用提供指导和参考。二维光子晶体板是由二维周期性结构的阵列构成的，通过设计出特定的结构和参数，可以实现类似一维光栅的效果，并且在光子晶体板中可以实现更多样化的束缚态BIC效应。在研究束缚态BIC时，我们需要计算器件的Q因子，以评估其性能和应用潜力。Comsol中提供了计算Q因子的工具和方法，可以结合模型和设定参数，通过数值模拟得到器件的谐振峰宽度和能量耗散等信息，并计算出Q因子。
软光栅技术及其应用：计算机图形学的奥秘揭秘
软光栅技术是一种利用计算机进行图形处理的技术，通过对虚拟三维场景进行光栅化处理，将其转化为二维图像的过程。与硬件光栅化相比，软光栅技术更加灵活，能够克服硬件光栅化的一些局限性，同时也能够在软件层面上...
【掌握Python图形算法】：构建高效可视化解决方案
[【掌握Python图形算法】：构建高效可视化解决方案](https://www.edureka.co/blog/wp-content/uploads/2019/10/TreeStructure-Data-Structures-in-Python-Edureka1.png) # 1. Python图形算法概述 图形算法，作为...
X-ray光栅分辨成像技术在微米尺度下的应用
# 1. 导言 - 研究背景和意义 - X-ray光栅分辨成像技术概述 - 微米尺度下成像的需求和挑战 ### 2. X-ray光栅分辨成像技术原理 X-ray光栅分辨成像技术作为一种先进的成像技术，在微米尺度下具有广泛的应用前景。为了...
【图像生成技术揭秘】：使用Python与GAN从零开始
# 1. 图像生成技术的起源与理论基础 ## 1.1 图像生成技术的起源 图像生成技术的起源可以追溯到计算机图形学的早期探索阶段，其目的是利用计算机技术创造出逼真的图像和动画。在这一过程中，科学家们不断地提出新的...
光栅衍射matlab代码-MP011-SOP:超快激光和电子衍射装置的标准操作程序
05-20
光栅衍射matlab代码MP011实验室的标准操作程序 该文档大致描述了飞秒激光系统的操作以及多伦多大学MP011室内的超快电子衍射（UED）设置。 它是由博士准备的。 ， ， 和 ; 上次更新时间为2015年2月。可以通过张贴评论或通过联系Dr.或任何一个来解决评论。 TL; DR 给样品真空室放气。 测量泵和探头的路径长度。 设置泵浦激光注量。 设置泵浦激光光斑尺寸。 安装原位条纹相机。 在样品架中安装TEM网格，以进行泵-探针的时间重叠。 设置条纹相机的泵浦光束。 抽空样品真空室。 （冷却样品。） 找到用于电子脉冲压缩的最佳RF功率和相位。 设置泵-探针空间重叠。 使用网格信号设置泵-探头的时间重叠。 表中的内容 1.安装概述 作为参考，本文的“实验方法”部分由，，和组成。 1.1激光系统 光路 1.2 UED设置 真空系统示意图 1.3信息技术 互联网路由器设置 设定值 价值 静态IP地址 128.100.148.66 DNS地址 128.100.75.10，128.100.75.99 网关地址 128.100.148.1 MAC地址 00-50-04-A3-6E-AB 子网掩
常见光学仿真设计软件
11-18
对所有光学软件做了一次总结，方便光学的菜鸟对本专业软件有一个全面认识
计算一维光子 晶体光学特性的python代码_python_代码_下载
07-03
用于计算一维光子晶体光学特性的 python 代码。该代码遵循以下指南： Yeh P, Yariv A, Hong CS (1977)周期性分层介质中的电磁传播。一、一般理论。 J Opt Soc Am 67:423–438 doi: 10.1364/JOSA.67.000423 目前我们只处理 TE 模式（这对布洛赫表面波特别有趣）。TM 模式计算将沿途添加 更多详情、使用方法，请下载后阅读README.md文件
使用python编写多普勒频移函数，绘制多普勒频移随速度变化的曲线，给出代码并举例，代码以markdown格式给出...
weixin_35750747的博客
02-17 588
下面是一段使用Python编写多普勒频移函数，绘制多普勒频移随速度变化的曲线的代码：python def DopplerShift(v): # v为物体的速度 f = np.arange(0, 1000, 0.1) # 频率范围为0~1000 Hz c = 343 #声速 f_shift = np.array([]) # 创建一个空数组用于存储多普勒...
尝试使用python调用origin绘制晶体能带图
最新发布
weixin_63763607的博客
06-03 858
这个代码并不完美，有些晶体的能带间隙会出现误判，关于originpro这个库的教程也不多，作者经过一些尝试，仅是设置了x,y轴的范围，和传入列表数据，和简单绘图，关于线条的宽度、类型设置、和添加复杂的标注没有涉及。这次我们尝试使用第三方库originpro绘图。
画能带结构图
lielie12138的博客
09-15 5730
1
能带结构（翻译）
neweroica的专栏
07-30 4442
 在分子中可能的电子能级是分立的、量子化的。但分子变得更大时，这些能级相互就会靠得更近。在晶体里能级之间靠得非常近以致于形成了连续的带子，这些带子的能量具有实际的利用目的。因此，晶体的电子结构可以用其能带结构来描述。能带的数学描述无限晶体的电子结构用能带图来描述，能带图给出k空间——叫作布里（Brillouin）渊区——中各点的电子轨道的能量。这与角分辨光电子能谱实验结果相
使用VirtualLab Fusion和Python进行跨平台光学建模和设计
Bonnie1985119的博客
08-29 606
复杂光学系统的建模和设计通常需要同时使用多个软件，因为单个软件很难为研究的不同领域提供所需的功能。通过标准批处理模式，我们演示了如何使用Python访问VirtualLab Fusion中的场求解器并使用Python执行光学仿真。 本示例演示了如何进行严格光栅分析和参数扫描。 ...
光子晶体透射谱计算
qq_23455525的博客
07-21 3241
光子晶体透射谱计算模型介绍FullWAVE仿真BandSOLVE仿真比较 RSoft中的FullWAVE可以用来计算光子晶体的透射谱，计算的结果可以和BandSOLVE的结果做对照。 模型介绍 如下图所示，晶格排布square，Unit cell为圆形的光子晶体。为了方便之后的对比，周期Period=1。 FullWAVE仿真 为了分析它的透射谱，我们选择了长条形仿真区域，入射光为pulse的plane wave,光源波长为2.22±1.11微米。 仿真结果：双击打开Data BROWSER中.pfm文件
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值