精华内容
下载资源
问答
  • 图像的批量数据增强。程序需要python环境,使用起来方便快捷。只需修改图片来源输出路径,并根据功能调整即可
  • (2)置换及循环节数的计算方法:对于有n个位置的手镯,有n种旋转置换n种翻转置换.  对于旋转置换: c(fi) = gcd(n,i) i为一次转过i颗宝石( i = 0 时 c=n;);  对于翻转置换:如果n为偶数:c(f) = n/2 的置换有n...
     

    Description

    Beads of red, blue or green colors are connected together into a circular necklace of n beads ( n < 24 ). If the repetitions that are produced by rotation around the center of the circular necklace or reflection to the axis of symmetry are all neglected, how many different forms of the necklace are there? 

     


    Input

    The input has several lines, and each line contains the input data n. 
    -1 denotes the end of the input file. 

     

    Output

    The output should contain the output data: Number of different forms, in each line correspondent to the input data.

     

    Sample Input

    4
    5
    -1

     

    Sample Output

    21
    39

     

    Source

     

    1、题目类型:Polya定理、组合数学、置换群。

    2、解题思路:Polya定理:(1)设G是p个对象的一个置换群,用k种颜色突然这p个对象,若一种染色方案在群G的作用下变为另一种方案,则这两个方案当作是同一种方案,这样的不同染色方案数为:

    (2)置换及循环节数的计算方法:对于有n个位置的手镯,有n种旋转置换和n种翻转置换.
                                              对于旋转置换: c(fi) = gcd(n,i)  i为一次转过i颗宝石( i = 0 时 c=n;);
                                              对于翻转置换:如果n为偶数:c(f) = n/2 的置换有n/2个; 
                                                                                c(f) = n/2+1 的置换有n/2个;
                                                               如果n为奇数:c(f) = n/2+1.

    3、注意事项:注意对于翻转置换过程中对于奇偶数情况的区分处理。

     

    相同的gcd合并在一起计算:

     

     1 #include<iostream>
     2 #include<cstdio>
     3 #include<cstring>
     4 #include<map>
     5 #include<set>
     6 #include<vector>
     7 using namespace std;
     8 #define ll long long
     9 ll pow_mod(ll a,ll i){
    10     if(i==0)
    11         return 1;
    12     ll t=pow_mod(a,i/2);
    13     ll ans=t*t;
    14     if(i&1)
    15         ans=ans*a;
    16     return ans;
    17 }
    18 
    19 
    20 
    21 vector<ll> divisor(ll n){
    22     vector<ll> res;
    23     for(ll i=1;i*i<=n;i++){
    24         if(n%i==0){
    25             res.push_back(i);
    26             if(i*i!=n){
    27                 res.push_back(n/i);
    28             }
    29         }
    30     }
    31     return res;
    32 }
    33 ll eular(ll n){
    34     ll res=1;
    35     for(ll i=2;i*i<=n;i++){
    36         if(n%i==0){
    37             n/=i,res*=i-1;
    38             while(n%i==0){
    39                 n/=i;
    40                 res*=i;
    41             }
    42         }
    43     }
    44     if(n>1) res*=n-1;
    45     return res;
    46 }
    47 ll polya(ll m,ll n){
    48     //map<ll,ll> primes = prime_factor(n);
    49     vector<ll> divs = divisor(n);
    50     ll res=0;
    51     for(ll i=0;i<divs.size();i++){
    52         ll euler=eular(divs[i]);
    53         res+=euler*pow_mod(m,n/divs[i]);
    54     }
    55     res/=n;
    56     return res;
    57 }
    58 int main()
    59 {
    60     ll n,m=3;
    61     while(~scanf("%I64d",&n) && n!=-1){
    62         if(n==0){
    63             puts("0");
    64             continue;
    65         }
    66         ll count=polya(m,n)*n;//旋转情况 
    67         if(n&1){//奇数 
    68             count+=n*pow_mod(m,n/2+1);//翻转情况 
    69         }
    70         else{//偶数 
    71             count += (pow_mod(m, n / 2 + 1) + pow_mod(m, n / 2)) * (n / 2);//翻转情况 
    72         }
    73         count/=2*n;
    74         printf("%I64d\n",count);
    75     }
    76     return 0;
    77 }
    View Code

     

     

    附上大神代码:

    相同的gcd合并在一起计算:

      1 #include <iostream>
      2 #include <map>
      3 #include <vector>
      4 using namespace std;
      5  
      6 #define LL long long
      7  
      8 inline LL power(LL p, LL n)
      9 {
     10     LL sum = 1;
     11     while (n)
     12     {
     13         if (n & 1)
     14             sum *= p;
     15         p *= p;
     16         n /= 2;
     17     }
     18     return sum;
     19 }
     20  
     21 //************************************
     22 // Method:    divisor
     23 // FullName:  divisor
     24 // Access:    public 
     25 // Returns:   vector<int> 约数
     26 // Qualifier: 约数枚举
     27 // Parameter: const int & n 目标数n
     28 //************************************
     29 vector<int> divisor(const int& n)
     30 {
     31     vector<int> res;
     32     for (int i = 1; i * i <= n; ++i)
     33     {
     34         if (n % i == 0)
     35         {
     36             res.push_back(i);
     37             if (i != n / i)
     38             {
     39                 res.push_back(n / i);
     40             }
     41         }
     42     }
     43  
     44     return res;
     45 }
     46  
     47 //************************************
     48 // Method:    prime_factor
     49 // FullName:  prime_factor
     50 // Access:    public 
     51 // Returns:   map<int, int>
     52 // Qualifier: 整数分解
     53 // Parameter: int n
     54 //************************************
     55 map<int, int> prime_factor(int n)
     56 {
     57     map<int, int> res;
     58     for (int i = 2; i * i <= n; ++i)
     59     {
     60         while (n % i == 0)
     61         {
     62             ++res[i];
     63             n /= i;
     64         }
     65     }
     66     if (n != 1)
     67     {
     68         res[n] = 1;
     69     }
     70     return res;
     71 }
     72  
     73 LL polya(const int& m, const int& n)
     74 {
     75     map<int, int> primes = prime_factor(n);
     76     vector<int> divs = divisor(n);
     77     LL res = 0;
     78     for (int i = 0; i < divs.size(); ++i)
     79     {
     80         // 求divs[i]的欧拉函数值
     81         LL euler = divs[i];
     82         for (map<int, int>::iterator it = primes.begin(); it != primes.end(); ++it)
     83         {
     84             int p = it->first;
     85             if (divs[i] % p == 0) euler = euler / p * (p - 1);
     86         }
     87  
     88         res += euler * power(m, n / divs[i]);
     89     }
     90  
     91     // 最后除以n
     92     res /= n;
     93     return res;
     94 }
     95  
     96 ///SubMain//
     97 int main(int argc, char *argv[])
     98 {
     99 #ifndef ONLINE_JUDGE
    100     freopen("in.txt", "r", stdin);
    101     freopen("out.txt", "w", stdout);
    102 #endif
    103     int n; const LL m = 3;
    104     while (~scanf("%d", &n) && n != -1)
    105     {
    106         if (n == 0)
    107         {
    108             puts("0");
    109             continue;
    110         }
    111  
    112         LL count = polya(m, n) * n;
    113         if (n & 1)
    114             count += n * power(m, n / 2 + 1);
    115         else
    116             count += (power(m, n / 2 + 1) + power(m, n / 2)) * (n / 2);
    117         count /= 2 * n;
    118         printf("%lld\n", count);
    119     }
    120 #ifndef ONLINE_JUDGE
    121     fclose(stdin);
    122     fclose(stdout);
    123     system("out.txt");
    124 #endif
    125     return 0;
    126 }
    View Code

     

    还有一种暴力求法:

     1 #include <iostream>
     2 using namespace std;
     3  
     4 #define LL long long
     5  
     6 int gcd(int a, int b)
     7 {
     8     return b == 0 ? a : gcd(b, a % b);
     9 }
    10  
    11 LL power(LL p, LL n)
    12 {
    13     LL sum = 1;
    14     while (n)
    15     {
    16         if (n & 1)
    17             sum *= p;
    18         p *= p;
    19         n /= 2;
    20  
    21     }
    22     return sum;
    23 }
    24  
    25 ///SubMain//
    26 int main(int argc, char *argv[])
    27 {
    28 #ifndef ONLINE_JUDGE
    29     freopen("in.txt", "r", stdin);
    30     freopen("out.txt", "w", stdout);
    31 #endif
    32     int n; const LL m = 3;
    33     while (~scanf("%d", &n) && n != -1)
    34     {
    35         if (n == 0)
    36         {
    37             puts("0");
    38             continue;
    39         }
    40         LL count = 0;
    41         for (int i = 1; i <= n; ++i)
    42             count += power(m, gcd(i, n));
    43         if (n & 1)
    44             count += n * power(m, n / 2 + 1);
    45         else
    46             count += n / 2 * (power(m, n / 2 + 1) + power(m, n / 2));
    47         count /= n * 2;
    48         printf("%lld\n", count);
    49     }
    50 #ifndef ONLINE_JUDGE
    51     fclose(stdin);
    52     fclose(stdout);
    53     system("out.txt");
    54 #endif
    55     return 0;
    56 }
    View Code

     

    转载于:https://www.cnblogs.com/UniqueColor/p/4776566.html

    展开全文
  • rotateY(Ydeg):沿着y轴正向旋转Y度 transform:rotateZ(Zdeg):沿着z轴正向旋转Z度 transform:rotate3d(x,y,z,deg):沿着自定义轴旋转deg为旋转度数 对于元素的旋转方向也是正负之分的,那么如何区分元素旋转方向的...

    前面我们已经介绍过了2D转换,那么我们即将学习的3D转换又是什么呢,它跟2D转换有什么不同呢?

    在我们日常生活的环境就是3D的,我们多看到的物体也都是3D的,而我们拍的照片就是3D物体在2D平面中呈现的样子 。

     3D的特点

    • 近大远小(离我们眼睛越近看上去越大,而离眼睛越远则看上去越小)
    • 物体后面遮挡不可见

    根据这些特点我们就可以在网页上模拟构建出3D效果。

    三维坐标系

    我们前面讲过的2D是一个平面坐标系,而3D则是三维坐标系。三维坐标系其实就是指立体空间,立体空间是由3个轴共同组成的。

    • x轴:水平向右。x右边是正值,左边是负值
    • y轴:垂直向下。y下面是正值,上面是负值
    • z轴:垂直屏幕。往外面是正值,往里面是负值

    在我们的网页中的左边原点就是我们屏幕的左上角。

     3D转换

    3D转换中我们主要来学习工作中最常用的3D位移和3D旋转

    主要知识点

    • 3D位移:translate3d(x,y,z)
    • 3D旋转:rotate3d(x,y,z)
    • 透视: perspective
    • 3D呈现transfrom-style

    3D移动 - translate3d

    3D移动在2D移动的基础上多加了一个可以移动的方向,就是z轴方向

    • transform:translateX(200px)仅在x轴上移动
    • transform:translateY(200px)仅在y轴上移动
    • transform:translateZ(200px)仅在z轴上移动
    • transform:translate3d(x,y,z)其中x、y、z分别指要移动的轴的方向的距离

    下面我们用代码来演示一下:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>3d demo</title>
        <style>
            div {
                width: 200px;
                height: 200px;
                background-color: pink;
                transform: translateX(100px) translateY(100px) translateZ(100px);
            }
        </style>
    </head>
    
    <body>
        <div></div>
    </body>
    
    </html>

    在上面这段代码中,我们让这个粉色盒子分别沿着x轴、y轴和z轴各移动了100像素,但是当我们运行起来是发现,z轴方向好像并没有明显的变化。这是因为z轴方向上的移动需要借助透视才能看出效果。接下来我们来看看什么是透视。

    透视perspective

    perspective 属性定义 3D 元素距视图的距离,以像素计。该属性允许您改变 3D 元素查看 3D 元素的视图。当为元素定义 perspective 属性时,其子元素会获得透视效果,而不是元素本身。

    我们平时去电影院看3D电影时,如果直接用眼睛去看其实并看不出明显的3D效果,而是每次电影院都会发给我们一个3D眼镜,那么借助3D眼镜我们再看电影3D效果就非常明显了。那么在我们的网页中如果也需要让我们看到的3D效果明显一些,那就需要借助透视

    • 如果想要在网页产生3D效果需要借助透视(理解成3D物体投影在2D平面上)
    • 模拟人类的视觉位置,借助perspective和translateZ可以模拟实现元素的近大远小的效果
    • 透视的单位是像素
    • 透视越小效果越明显

    注意:

    1. 透视必须写在被观察元素的父盒子上面
    2. perspective 属性只影响 3D 转换元素
    3. 要想改变translateZ实现近大远小效果,则必须要借助透视,否则translateZ是没有效果的
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>3d demo</title>
        <style>
            body{
                perspective: 200px;
            }
            div {
                width: 200px;
                height: 200px;
                background-color: pink;
                transform: translateX(100px) translateY(100px) translateZ(100px);
            }
        </style>
    </head>
    
    <body>
        <div></div>
    </body>
    
    </html>

    上面的代码中我们给div的父元素body添加一个透视,这时再看这个粉色盒子发现明显比不加透视时变大了很多。这就是透视的作用。上面的示例可能还不够明显,接下来我们再看一个rotat3d的例子效果会更明显

    3D旋转 rotate3d

    3D旋转指可以让元素在三维平面内沿着x轴、y轴、z轴或自定义轴进行旋转

    语法:

    • transform:rotateX(Xdeg):沿着x轴正向旋转X度
    • transform:rotateY(Ydeg):沿着y轴正向旋转Y度
    • transform:rotateZ(Zdeg):沿着z轴正向旋转Z度
    • transform:rotate3d(x,y,z,deg):沿着自定义轴旋转deg为旋转度数

    对于元素的旋转方向也是正负之分的,那么如何区分元素旋转方向的正负呢,下面我们来学习一下左手准则,用我们的左手即可判断方向的正负

    左手准则:

    • 左手的手指指向x轴、y轴、z轴的正方向
    • 其余手指的弯曲方向就是该元素沿着x轴、y轴、z轴旋转的方向

     下面的代码是沿着x轴正向旋转的示例

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
    <style>
    #div1
    {
    position: relative;
    height: 150px;
    width: 150px;
    margin: 50px;
    padding:10px;
    border: 1px solid black;
    perspective:50;
    -webkit-perspective:150; /* Safari and Chrome */
    }
    
    #div2
    {
    padding:50px;
    position: absolute;
    border: 1px solid black;
    background-color: pink;
    transform: rotateX(45deg);
    -webkit-transform: rotateX(45deg); /* Safari and Chrome */
    }
    </style>
    </head>
    
    <body>
    
    <div id="div1">
      <div id="div2">HELLO</div>
    </div>
     
    </body>
    </html>

     上述代码中如果我们不加透视效果则运行后就是下面第一个图的样子,如果使用了透视则就是第二张图的样子,这样来看透视的作用就很明显了。

    3D呈现 transform-style

    transform-style 属性规定如何在 3D 空间中呈现被嵌套的元素。

    注释:

    1. 该属性必须与 transform 属性一同使用
    2. 代码与透视一样必须写在父级元素上,但会作用在子元素上

    语法:transform-style: flat | preserve-3d;

    描述
    flat 子元素将不保留其 3D 位置。
    preserve-3d 子元素将保留其 3D 位置。

    下面来看个例子:

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
    <style>
    body{
    	perspective: 300px;
    }
    .box{
    	position:relative;
    	width:200px;
    	height:200px;
    	margin:100px auto;
        transition:all 1s;
        transform-style: preserve-3d;
    }
    .box:hover{
    	transform:rotateY(45deg)
    }
    .box div{
        position:absolute;
        top:0;
        left:0;
        width:100%;
        height:100%;
        background-color: pink;
    }
    
    .box div:last-child{
    	background-color:green;
        transform:rotateX(60deg)
    }
    </style>
    </head>
    
    <body>
    
    <div class="box">
      <div></div>
      <div></div>
    </div>
    
    </body>
    </html>
    

    上面代码中一个大盒子中嵌套两个小盒子,当我们鼠标悬浮到大盒子上时,我们先让绿色小盒子沿着X轴正向旋转60度,然后再让大盒子沿着Y轴正向旋转45度 。那么在我们不用transform-style修饰时会得到如下第一个图的效果,而使用了transform-style后会出现第二张图的样子。这个例子很好的描述了transform-style的作用(保留子元素的3D效果)。

     

    案例

    实现两个翻转的盒子

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>3d demo</title>
        <style>
            body{
                perspective: 350px;
            }
            .box {
                position: relative;
                width: 200px;
                height: 200px;
                margin: 100px auto;
                transform-style: preserve-3d;
                transition: all 0.4s;
            }
    
            .box div {
                position: absolute;
                width: 200px;
                height: 200px;
                line-height: 200px;
                text-align: center;
                border-radius: 50%;
            }
    
            .box div:first-child {
                background-color: pink;
                z-index: 1;
            }
    
            .box div:last-child {
                background-color: green;
                transform: rotateY(180deg);
            }
    
            .box:hover{
                transform: rotateY(180deg);
            }
        </style>
    </head>
    
    <body>
        <div class="box">
            <div>Hello</div>
            <div>world</div>
        </div>
    </body>
    
    </html>

    3D导航栏案例

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>3d demo</title>
        <style>
            .box {
                position: relative;           
                transform-style: preserve-3d;
                transition: all 0.4s;
            }
    
            .box div {
                width: 200px;
                height: 50px;
                line-height: 50px;
                text-align: center;
                background-color:pink;
            }
    
            .box .shn {
                background-color: green;
               transform: translateY(-25px) translateZ(-25px) rotateX(-90deg)
            }
    
            .box:hover{
                transform: translateY(-50px) rotateX(90deg);
            }
    
            li{
                float: left;
                list-style: none;
            }
        </style>
    </head>
    
    <body>
    <ul>
    <li>
        <div class="box">
            <div>导航一</div>
            <div class="shn">导航一</div>
        </div>
    </li>
    <li>
        <div class="box">
            <div>导航二</div>
            <div class="shn">导航二</div>
        </div>
    </li>
    <li>
        <div class="box">
            <div>导航三</div>
            <div class="shn">导航三</div>
        </div>
    </li>
    </ul>
    </body>
    
    </html>

    旋转木马案例

    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="UTF-8">
        <title>旋转木马</title>
        <style>
            body {
                perspective: 1000px;
            }
    
            section {
                position: relative;
                width: 300px;
                height: 200px;
                margin: 200px auto;
                transform-style: preserve-3d;
                animation: rotate 10s linear infinite;
                background: url(caoyaolu.jpg) no-repeat center;
            }
    
            section div {
                position: absolute;
                width: 100%;
                height: 100%;
                background: url(timg.jfif) no-repeat;
            }
    
            section:hover {
                animation-play-state: paused;
            }
    
            section div:first-child {
                transform: translateZ(400px);
            }
    
            section div:nth-child(2) {
                transform: rotateY(60deg) translateZ(400px);
            }
    
            section div:nth-child(3) {
                transform: rotateY(120deg) translateZ(400px);
            }
    
            section div:nth-child(4) {
                transform: rotateY(180deg) translateZ(400px);
            }
    
            section div:nth-child(5) {
                transform: rotateY(240deg) translateZ(400px);
            }
    
            section div:nth-child(6) {
                transform: rotateY(300deg) translateZ(400px);
            }
    
            @keyframes rotate {
                0% {
                    transform: rotateY(0deg);
                }
    
                100% {
                    transform: rotateY(100deg);
                }
            }
        </style>
    </head>
    
    <body>
        <section>
            <div></div>
            <div></div>
            <div></div>
            <div></div>
            <div></div>
            <div></div>
        </section>
    </body>
    
    </html>

     

    展开全文
  • cocos2d-x实现3d翻转区分正反面

    千次阅读 2014-02-18 22:45:04
    实现原理 通过OrbitCamera实现立体翻转,当精灵翻转到90度时切换精灵纹理 代码解析 1.创建一个精灵,设定精灵的userdata用于确定切换图片 auto poker=Sprite::...2.创建一个重复动作,包含一个3d旋转动作调用

    实现原理

    通过OrbitCamera实现立体翻转,当精灵翻转到90度时切换精灵纹理

    代码解析

    1.创建一个精灵,设定精灵的userdata用于确定切换图片
        auto poker=Sprite::create("poker/poker_3_1.png");
        poker->setUserData((void *)1);
    
    2.创建一个重复动作,包含一个3d旋转动作和调用更换精灵图片的动作
        auto *flip3d = OrbitCamera::create(2, -45, 0, 90, 180, 0, 0);
        auto *changeImageAction=CallFuncN::create( CC_CALLBACK_1(WelcomeScene::changePokerImage, this));
        auto *realiteFlip3d = Repeat::create(Sequence::create(flip3d,changeImageAction, NULL), -1);
    
    3.实现更换精灵图片的动作

    void WelcomeScene::changePokerImage(Object* pSender){
        Sprite* sprite=(Sprite*)pSender;
        int flag=(int)sprite->getUserData();
        if(flag==1){
            sprite->setTexture("poker/poker_back.png");
        }else{
            sprite->setTexture("poker/poker_3_1.png");
        }
        
        sprite->setUserData((void*)(1-flag));
    }
    

    效果

    展开全文
  • # 获取时间戳,用于区分图像 now = time.time() tail_time = str(round(now * 1000000))[-4:] # 时间戳尾数 head_time = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time())) # 时间标签 label = str...

    元学习论文总结||小样本学习论文总结

    2017-2019年计算机视觉顶会文章收录 AAAI2017-2019 CVPR2017-2019 ECCV2018 ICCV2017-2019 ICLR2017-2019 NIPS2017-2019

    一:日志依赖

    https://blog.csdn.net/weixin_41803874/article/details/81201807

     

    数据操作完整源码自 vieo.zhu@foxmail.com 申请

    二:代码实现

    from diagnose_logging import Logger
    from PIL import Image
    import os
    
    # 声明日志
    log = Logger('img_pre.py')
    logger = log.getlog()
    
    
    class ImgPre:
        def __init__(self, rootPath, export_path_base):
            self.rootPath = rootPath  # 图像完整路径
            self.export_path_base = export_path_base
    
            # 创建输出根目录
            try:
                if not os.path.exists(export_path_base):
                    os.mkdir(export_path_base)
            except Exception as e:
                logger.error(e)
            logger.info('ImgPre: %s', rootPath)
    
        def get_savename(self, operate):
            """
            :param export_path_base: 图像输出路径
            :param operate: 脸部区域名
    
            :return: 返回图像存储名
            """
            try:
                import time
                # 获取时间戳,用于区分图像
                now = time.time()
                tail_time = str(round(now * 1000000))[-4:]  # 时间戳尾数
                head_time = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
                # 时间标签
                label = str(head_time + tail_time)
    
                # 输出文件夹
                export_path_base = self.export_path_base
                # 子文件夹以“操作operate”命名
                out_path = export_path_base + operate
                # 创建子文件夹
                if not os.path.exists(out_path):
                    os.mkdir(out_path)
    
                # 存储完整路径
                savename = out_path + '/' + operate + '_' + label + ".jpg"
    
                # 日志
                logger.info('save:%s', savename)
                return savename
    
            except Exception as e:
                logger.error('get_savename ERROR')
                logger.error(e)
    
        def lightness(self, light):
            """改变图像亮度.
            推荐值:
                0.87,1.07
            明亮程度
                darker < 1.0 <lighter
            """
            try:
                operate = 'lightness_' + str(light)
                # 图像完整路径
                rootPath = self.rootPath
    
                with Image.open(rootPath) as image:
                    # 图像左右翻转
                    out = image.point(lambda p: p * light)
                    # 重命名
                    savename = self.get_savename(operate)
                    # 图像存储
                    out.save(savename)
    
                # 日志
                # logger.info(operate)
            except Exception as e:
                logger.error('ERROR %s', operate)
                logger.error(e)
    
    
        def rotate(self, angle):
            """图像旋转15度、30度."""
            try:
                operate = 'rotate_' + str(angle)
                # 图像完整路径
                rootPath = self.rootPath
    
                with Image.open(rootPath) as image:
                    # 图像左右翻转
                    out = image.rotate(angle)
                    # 重命名
                    savename = self.get_savename(operate)
                    # 图像存储
                    out.save(savename, quality=100)
    
                # 日志
                # logger.info(operate)
            except Exception as e:
                logger.error('ERROR %s', operate)
                logger.error(e)
    
        def transpose(self):
            """图像左右翻转操作."""
            try:
                operate = 'transpose'
                # 图像完整路径
                rootPath = self.rootPath
    
                with Image.open(rootPath) as image:
                    # 图像左右翻转
                    out = image.transpose(Image.FLIP_LEFT_RIGHT)
                    # 重命名
                    savename = self.get_savename(operate)
                    # 图像存储
                    out.save(savename, quality=100)  # quality=100
    
                # 日志
                # logger.info(operate)
            except Exception as e:
                logger.error('ERROR %s', operate)
                logger.error(e)
    
        def deform(self):
            """图像拉伸."""
            try:
                operate = 'deform'
                # 图像完整路径
                rootPath = self.rootPath
    
                with Image.open(rootPath) as image:
                    w, h = image.size
                    w = int(w)
                    h = int(h)
                    # 拉伸成宽为w的正方形
                    out_ww = image.resize((int(w), int(w)))
                    savename = self.get_savename(operate + '_ww')
                    out_ww.save(savename, quality=100)
                    # 拉伸成宽为h的正方形
                    out_ww = image.resize((int(h), int(h)))
                    savename = self.get_savename(operate + '_hh')
                    out_ww.save(savename, quality=100)
    
                # 日志
                # logger.info(operate)
            except Exception as e:
                logger.error('ERROR %s', operate)
                logger.error(e)
    
        def crop(self):
            """提取四个角落和中心区域."""
            try:
                operate = 'crop'
                # 图像完整路径
                rootPath = self.rootPath
    
                with Image.open(rootPath) as image:
                    w, h = image.size
                    # 切割后尺寸
                    scale = 0.875
                    # 切割后长宽
                    ww = int(w * scale)
                    hh = int(h * scale)
                    # 图像起点,左上角坐标
                    x = y = 0
    
                    # 切割左上角
                    x_lu = x
                    y_lu = y
                    out_lu = image.crop((x_lu, y_lu, ww, hh))
                    savename = self.get_savename(operate + '_lu')
                    out_lu.save(savename, quality=100)
                    # logger.info(operate + '_lu')
    
                    # 切割左下角
                    x_ld = int(x)
                    y_ld = int(y + (h - hh))
                    out_ld = image.crop((x_ld, y_ld, ww, hh))
                    savename = self.get_savename(operate + '_ld')
                    out_ld.save(savename, quality=100)
                    # logger.info(operate + '_ld')
    
                    # 切割右上角
                    x_ru = int(x + (w - ww))
                    y_ru = int(y)
                    out_ru = image.crop((x_ru, y_ru, w, hh))
                    savename = self.get_savename(operate + '_ru')
                    out_ru.save(savename, quality=100)
                    # logger.info(operate + '_ru')
    
                    # 切割右下角
                    x_rd = int(x + (w - ww))
                    y_rd = int(y + (h - hh))
                    out_rd = image.crop((x_rd, y_rd, w, h))
                    savename = self.get_savename(operate + '_rd')
                    out_rd.save(savename, quality=100)
                    # logger.info(operate + '_rd')
    
                    # 切割中心
                    x_c = int(x + (w - ww) / 2)
                    y_c = int(y + (h - hh) / 2)
                    out_c = image.crop((x_c, y_c, ww, hh))
                    savename = self.get_savename(operate + '_c')
                    out_c.save(savename, quality=100)
                    # logger.info('提取中心')
            except Exception as e:
                logger.error('ERROR %s', operate)
                logger.error(e)
    
    
    def test():
        # 源地址和输出地址
        rootPath = 'E:/face/1.jpg'
        export_path_base = 'E:/face/image/'
        # 声明类对象
        imgPre = ImgPre(rootPath, export_path_base)
    
        imgPre.deform()
        imgPre.transpose()
        imgPre.rotate(15)
        imgPre.rotate(30)
        imgPre.crop()
        imgPre.lightness(1.07)
        imgPre.lightness(0.87)
        
    
    if __name__ == '__main__':
        import datetime
        print('start...')
        # 计时
        start_time = datetime.datetime.now()
    
        test()
    
        end_time = datetime.datetime.now()
        time_consume = (end_time - start_time).microseconds / 1000000
    
        logger.info('start_time: %s', start_time)
        logger.info('end_time: %s', end_time)
        logger.info('time_consume: %s(s)', time_consume)  # 0.280654(s)
    
        logger.info('main finish')
    

     

    展开全文
  • 翻转子串

    2015-07-31 22:45:39
    字符串中字符为英文字母空格,区分大小写 解析:通过旋转一个字串即可 public boolean checkReverseEqual(String s1, String s2) { //安全性检查 if(s1==null||s2==null) return false; String t
  • 杨净 发自 凹非寺 量子位 报道 | 公众号 QbitAI过去现在的边界,到底在哪里?人类,又是如何在时间混沌中区分出过往与当下的?注意,这不是一个哲学问题。(手动狗头)而是科学家们的最...
  • 翻转字串

    2020-02-27 20:21:19
    题目描述 假定我们都知道非常高效的算法来检查一个单词是否为其他字符串的子串。...字符串中字符为英文字母空格,区分大小写,字符串长度小于等于1000。 测试样例: “Hello world”,"worldhe...
  • 实现卡片翻转的动画效果

    万次阅读 多人点赞 2016-02-27 20:12:59
    在Android设计中, 经常会使用卡片元素, 正面显示图片或主要信息, 背面显示详细内容, 如网易有道词典的单词翻转和海底捞的食谱展示. 实现卡片视图非常容易, 那么如何实现翻转动画呢? 在TB吃海底捞时, 使用Pad点餐, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,896
精华内容 1,558
关键字:

区分旋转和翻转